Elliott Hughes | 2faa5f1 | 2012-01-30 14:42:07 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2011 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 | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 16 | |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 17 | #include "heap.h" |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 18 | |
Brian Carlstrom | 5643b78 | 2012-02-05 12:32:53 -0800 | [diff] [blame] | 19 | #include <sys/types.h> |
| 20 | #include <sys/wait.h> |
| 21 | |
Brian Carlstrom | 58ae941 | 2011-10-04 00:56:06 -0700 | [diff] [blame] | 22 | #include <limits> |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 23 | #include <vector> |
| 24 | |
Elliott Hughes | 767a147 | 2011-10-26 18:49:02 -0700 | [diff] [blame] | 25 | #include "debugger.h" |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 26 | #include "gc/atomic_stack.h" |
| 27 | #include "gc/card_table.h" |
| 28 | #include "gc/heap_bitmap.h" |
Mathieu Chartier | 1c23e1e | 2012-10-12 14:14:11 -0700 | [diff] [blame] | 29 | #include "gc/large_object_space.h" |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 30 | #include "gc/mark_sweep.h" |
| 31 | #include "gc/mod_union_table.h" |
| 32 | #include "gc/space.h" |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame] | 33 | #include "image.h" |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 34 | #include "object.h" |
Ian Rogers | 6d4d9fc | 2011-11-30 16:24:48 -0800 | [diff] [blame] | 35 | #include "object_utils.h" |
Brian Carlstrom | 5643b78 | 2012-02-05 12:32:53 -0800 | [diff] [blame] | 36 | #include "os.h" |
Mathieu Chartier | 7664f5c | 2012-06-08 18:15:32 -0700 | [diff] [blame] | 37 | #include "ScopedLocalRef.h" |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 38 | #include "scoped_thread_state_change.h" |
Ian Rogers | 1f53934 | 2012-10-03 21:09:42 -0700 | [diff] [blame] | 39 | #include "sirt_ref.h" |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 40 | #include "stl_util.h" |
Elliott Hughes | 8d768a9 | 2011-09-14 16:35:25 -0700 | [diff] [blame] | 41 | #include "thread_list.h" |
Elliott Hughes | 767a147 | 2011-10-26 18:49:02 -0700 | [diff] [blame] | 42 | #include "timing_logger.h" |
| 43 | #include "UniquePtr.h" |
Elliott Hughes | eac7667 | 2012-05-24 21:56:51 -0700 | [diff] [blame] | 44 | #include "well_known_classes.h" |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 45 | |
| 46 | namespace art { |
| 47 | |
Mathieu Chartier | 0051be6 | 2012-10-12 17:47:11 -0700 | [diff] [blame] | 48 | const double Heap::kDefaultTargetUtilization = 0.5; |
| 49 | |
Elliott Hughes | ae80b49 | 2012-04-24 10:43:17 -0700 | [diff] [blame] | 50 | static bool GenerateImage(const std::string& image_file_name) { |
Brian Carlstrom | a004aa9 | 2012-02-08 18:05:09 -0800 | [diff] [blame] | 51 | const std::string boot_class_path_string(Runtime::Current()->GetBootClassPathString()); |
Brian Carlstrom | 5643b78 | 2012-02-05 12:32:53 -0800 | [diff] [blame] | 52 | std::vector<std::string> boot_class_path; |
| 53 | Split(boot_class_path_string, ':', boot_class_path); |
Brian Carlstrom | b279337 | 2012-03-17 18:27:16 -0700 | [diff] [blame] | 54 | if (boot_class_path.empty()) { |
| 55 | LOG(FATAL) << "Failed to generate image because no boot class path specified"; |
| 56 | } |
Brian Carlstrom | 5643b78 | 2012-02-05 12:32:53 -0800 | [diff] [blame] | 57 | |
| 58 | std::vector<char*> arg_vector; |
| 59 | |
| 60 | std::string dex2oat_string(GetAndroidRoot()); |
Elliott Hughes | 67d9200 | 2012-03-26 15:08:51 -0700 | [diff] [blame] | 61 | dex2oat_string += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat"); |
Brian Carlstrom | 5643b78 | 2012-02-05 12:32:53 -0800 | [diff] [blame] | 62 | const char* dex2oat = dex2oat_string.c_str(); |
| 63 | arg_vector.push_back(strdup(dex2oat)); |
| 64 | |
| 65 | std::string image_option_string("--image="); |
| 66 | image_option_string += image_file_name; |
| 67 | const char* image_option = image_option_string.c_str(); |
| 68 | arg_vector.push_back(strdup(image_option)); |
| 69 | |
| 70 | arg_vector.push_back(strdup("--runtime-arg")); |
| 71 | arg_vector.push_back(strdup("-Xms64m")); |
| 72 | |
| 73 | arg_vector.push_back(strdup("--runtime-arg")); |
| 74 | arg_vector.push_back(strdup("-Xmx64m")); |
| 75 | |
| 76 | for (size_t i = 0; i < boot_class_path.size(); i++) { |
| 77 | std::string dex_file_option_string("--dex-file="); |
| 78 | dex_file_option_string += boot_class_path[i]; |
| 79 | const char* dex_file_option = dex_file_option_string.c_str(); |
| 80 | arg_vector.push_back(strdup(dex_file_option)); |
| 81 | } |
| 82 | |
| 83 | std::string oat_file_option_string("--oat-file="); |
| 84 | oat_file_option_string += image_file_name; |
| 85 | oat_file_option_string.erase(oat_file_option_string.size() - 3); |
| 86 | oat_file_option_string += "oat"; |
| 87 | const char* oat_file_option = oat_file_option_string.c_str(); |
| 88 | arg_vector.push_back(strdup(oat_file_option)); |
| 89 | |
| 90 | arg_vector.push_back(strdup("--base=0x60000000")); |
| 91 | |
Elliott Hughes | 48436bb | 2012-02-07 15:23:28 -0800 | [diff] [blame] | 92 | std::string command_line(Join(arg_vector, ' ')); |
Brian Carlstrom | 5643b78 | 2012-02-05 12:32:53 -0800 | [diff] [blame] | 93 | LOG(INFO) << command_line; |
| 94 | |
Elliott Hughes | 48436bb | 2012-02-07 15:23:28 -0800 | [diff] [blame] | 95 | arg_vector.push_back(NULL); |
Brian Carlstrom | 5643b78 | 2012-02-05 12:32:53 -0800 | [diff] [blame] | 96 | char** argv = &arg_vector[0]; |
| 97 | |
| 98 | // fork and exec dex2oat |
| 99 | pid_t pid = fork(); |
| 100 | if (pid == 0) { |
| 101 | // no allocation allowed between fork and exec |
| 102 | |
| 103 | // change process groups, so we don't get reaped by ProcessManager |
| 104 | setpgid(0, 0); |
| 105 | |
| 106 | execv(dex2oat, argv); |
| 107 | |
| 108 | PLOG(FATAL) << "execv(" << dex2oat << ") failed"; |
| 109 | return false; |
| 110 | } else { |
| 111 | STLDeleteElements(&arg_vector); |
| 112 | |
| 113 | // wait for dex2oat to finish |
| 114 | int status; |
| 115 | pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0)); |
| 116 | if (got_pid != pid) { |
| 117 | PLOG(ERROR) << "waitpid failed: wanted " << pid << ", got " << got_pid; |
| 118 | return false; |
| 119 | } |
| 120 | if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) { |
| 121 | LOG(ERROR) << dex2oat << " failed: " << command_line; |
| 122 | return false; |
| 123 | } |
| 124 | } |
| 125 | return true; |
| 126 | } |
| 127 | |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 128 | void Heap::UnReserveOatFileAddressRange() { |
| 129 | oat_file_map_.reset(NULL); |
| 130 | } |
| 131 | |
Mathieu Chartier | 0051be6 | 2012-10-12 17:47:11 -0700 | [diff] [blame] | 132 | Heap::Heap(size_t initial_size, size_t growth_limit, size_t min_free, size_t max_free, |
| 133 | double target_utilization, size_t capacity, |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 134 | const std::string& original_image_file_name, bool concurrent_gc) |
| 135 | : alloc_space_(NULL), |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 136 | card_table_(NULL), |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 137 | concurrent_gc_(concurrent_gc), |
| 138 | have_zygote_space_(false), |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 139 | card_marking_disabled_(false), |
| 140 | is_gc_running_(false), |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 141 | last_gc_type_(kGcTypeNone), |
Mathieu Chartier | 1c23e1e | 2012-10-12 14:14:11 -0700 | [diff] [blame] | 142 | enforce_heap_growth_rate_(false), |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 143 | growth_limit_(growth_limit), |
Mathieu Chartier | 0051be6 | 2012-10-12 17:47:11 -0700 | [diff] [blame] | 144 | max_allowed_footprint_(initial_size), |
Mathieu Chartier | 7664f5c | 2012-06-08 18:15:32 -0700 | [diff] [blame] | 145 | concurrent_start_size_(128 * KB), |
| 146 | concurrent_min_free_(256 * KB), |
Mathieu Chartier | 0051be6 | 2012-10-12 17:47:11 -0700 | [diff] [blame] | 147 | concurrent_start_bytes_(initial_size - concurrent_start_size_), |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 148 | sticky_gc_count_(0), |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 149 | total_bytes_freed_(0), |
| 150 | total_objects_freed_(0), |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 151 | large_object_threshold_(3 * kPageSize), |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 152 | num_bytes_allocated_(0), |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 153 | verify_missing_card_marks_(false), |
| 154 | verify_system_weaks_(false), |
| 155 | verify_pre_gc_heap_(false), |
| 156 | verify_post_gc_heap_(false), |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 157 | verify_mod_union_table_(false), |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 158 | partial_gc_frequency_(10), |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 159 | min_alloc_space_size_for_sticky_gc_(2 * MB), |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 160 | min_remaining_space_for_sticky_gc_(1 * MB), |
Mathieu Chartier | 7664f5c | 2012-06-08 18:15:32 -0700 | [diff] [blame] | 161 | last_trim_time_(0), |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 162 | requesting_gc_(false), |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 163 | max_allocation_stack_size_(MB), |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 164 | reference_referent_offset_(0), |
| 165 | reference_queue_offset_(0), |
| 166 | reference_queueNext_offset_(0), |
| 167 | reference_pendingNext_offset_(0), |
| 168 | finalizer_reference_zombie_offset_(0), |
Mathieu Chartier | 0051be6 | 2012-10-12 17:47:11 -0700 | [diff] [blame] | 169 | min_free_(min_free), |
| 170 | max_free_(max_free), |
| 171 | target_utilization_(target_utilization), |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 172 | total_paused_time_(0), |
| 173 | total_wait_time_(0), |
| 174 | measure_allocation_time_(false), |
| 175 | total_allocation_time_(0), |
Elliott Hughes | b25c3f6 | 2012-03-26 16:35:06 -0700 | [diff] [blame] | 176 | verify_objects_(false) { |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 177 | if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) { |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 178 | LOG(INFO) << "Heap() entering"; |
Brian Carlstrom | 0a5b14d | 2011-09-27 13:29:15 -0700 | [diff] [blame] | 179 | } |
| 180 | |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 181 | live_bitmap_.reset(new HeapBitmap(this)); |
| 182 | mark_bitmap_.reset(new HeapBitmap(this)); |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 183 | |
Ian Rogers | 30fab40 | 2012-01-23 15:43:46 -0800 | [diff] [blame] | 184 | // Requested begin for the alloc space, to follow the mapped image and oat files |
| 185 | byte* requested_begin = NULL; |
Brian Carlstrom | 5643b78 | 2012-02-05 12:32:53 -0800 | [diff] [blame] | 186 | std::string image_file_name(original_image_file_name); |
| 187 | if (!image_file_name.empty()) { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 188 | ImageSpace* image_space = NULL; |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 189 | |
Brian Carlstrom | 5643b78 | 2012-02-05 12:32:53 -0800 | [diff] [blame] | 190 | if (OS::FileExists(image_file_name.c_str())) { |
| 191 | // If the /system file exists, it should be up-to-date, don't try to generate |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 192 | image_space = ImageSpace::Create(image_file_name); |
Brian Carlstrom | 5643b78 | 2012-02-05 12:32:53 -0800 | [diff] [blame] | 193 | } else { |
| 194 | // If the /system file didn't exist, we need to use one from the art-cache. |
| 195 | // If the cache file exists, try to open, but if it fails, regenerate. |
| 196 | // If it does not exist, generate. |
| 197 | image_file_name = GetArtCacheFilenameOrDie(image_file_name); |
| 198 | if (OS::FileExists(image_file_name.c_str())) { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 199 | image_space = ImageSpace::Create(image_file_name); |
Brian Carlstrom | 5643b78 | 2012-02-05 12:32:53 -0800 | [diff] [blame] | 200 | } |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 201 | if (image_space == NULL) { |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 202 | CHECK(GenerateImage(image_file_name)) << "Failed to generate image: " << image_file_name; |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 203 | image_space = ImageSpace::Create(image_file_name); |
Brian Carlstrom | 5643b78 | 2012-02-05 12:32:53 -0800 | [diff] [blame] | 204 | } |
| 205 | } |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 206 | |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 207 | CHECK(image_space != NULL) << "Failed to create space from " << image_file_name; |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 208 | AddSpace(image_space); |
Ian Rogers | 30fab40 | 2012-01-23 15:43:46 -0800 | [diff] [blame] | 209 | // Oat files referenced by image files immediately follow them in memory, ensure alloc space |
| 210 | // isn't going to get in the middle |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 211 | byte* oat_end_addr = image_space->GetImageHeader().GetOatEnd(); |
| 212 | CHECK_GT(oat_end_addr, image_space->End()); |
| 213 | |
| 214 | // Reserve address range from image_space->End() to image_space->GetImageHeader().GetOatEnd() |
| 215 | uintptr_t reserve_begin = RoundUp(reinterpret_cast<uintptr_t>(image_space->End()), kPageSize); |
| 216 | uintptr_t reserve_end = RoundUp(reinterpret_cast<uintptr_t>(oat_end_addr), kPageSize); |
| 217 | oat_file_map_.reset(MemMap::MapAnonymous("oat file reserve", |
| 218 | reinterpret_cast<byte*>(reserve_begin), |
| 219 | reserve_end - reserve_begin, PROT_READ)); |
| 220 | |
Ian Rogers | 30fab40 | 2012-01-23 15:43:46 -0800 | [diff] [blame] | 221 | if (oat_end_addr > requested_begin) { |
| 222 | requested_begin = reinterpret_cast<byte*>(RoundUp(reinterpret_cast<uintptr_t>(oat_end_addr), |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 223 | kPageSize)); |
Brian Carlstrom | 58ae941 | 2011-10-04 00:56:06 -0700 | [diff] [blame] | 224 | } |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 225 | } |
| 226 | |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 227 | // Allocate the large object space. |
| 228 | large_object_space_.reset(FreeListSpace::Create("large object space", NULL, capacity)); |
Mathieu Chartier | 8e9a149 | 2012-10-04 12:25:40 -0700 | [diff] [blame] | 229 | live_bitmap_->SetLargeObjects(large_object_space_->GetLiveObjects()); |
| 230 | mark_bitmap_->SetLargeObjects(large_object_space_->GetMarkObjects()); |
| 231 | |
Mathieu Chartier | 1c23e1e | 2012-10-12 14:14:11 -0700 | [diff] [blame] | 232 | UniquePtr<DlMallocSpace> alloc_space(DlMallocSpace::Create("alloc space", initial_size, |
| 233 | growth_limit, capacity, |
| 234 | requested_begin)); |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 235 | alloc_space_ = alloc_space.release(); |
Mathieu Chartier | 1c23e1e | 2012-10-12 14:14:11 -0700 | [diff] [blame] | 236 | alloc_space_->SetFootprintLimit(alloc_space_->Capacity()); |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 237 | CHECK(alloc_space_ != NULL) << "Failed to create alloc space"; |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 238 | AddSpace(alloc_space_); |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 239 | |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 240 | // Spaces are sorted in order of Begin(). |
| 241 | byte* heap_begin = spaces_.front()->Begin(); |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 242 | size_t heap_capacity = spaces_.back()->End() - spaces_.front()->Begin(); |
| 243 | if (spaces_.back()->IsAllocSpace()) { |
| 244 | heap_capacity += spaces_.back()->AsAllocSpace()->NonGrowthLimitCapacity(); |
| 245 | } |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 246 | |
Ian Rogers | 30fab40 | 2012-01-23 15:43:46 -0800 | [diff] [blame] | 247 | // Mark image objects in the live bitmap |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 248 | // TODO: C++0x |
| 249 | for (Spaces::iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
| 250 | Space* space = *it; |
Ian Rogers | 30fab40 | 2012-01-23 15:43:46 -0800 | [diff] [blame] | 251 | if (space->IsImageSpace()) { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 252 | ImageSpace* image_space = space->AsImageSpace(); |
| 253 | image_space->RecordImageAllocations(image_space->GetLiveBitmap()); |
Ian Rogers | 30fab40 | 2012-01-23 15:43:46 -0800 | [diff] [blame] | 254 | } |
| 255 | } |
| 256 | |
Elliott Hughes | 6c9c06d | 2011-11-07 16:43:47 -0800 | [diff] [blame] | 257 | // Allocate the card table. |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 258 | card_table_.reset(CardTable::Create(heap_begin, heap_capacity)); |
| 259 | CHECK(card_table_.get() != NULL) << "Failed to create card table"; |
Ian Rogers | 5d76c43 | 2011-10-31 21:42:49 -0700 | [diff] [blame] | 260 | |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 261 | mod_union_table_.reset(new ModUnionTableToZygoteAllocspace<ModUnionTableReferenceCache>(this)); |
| 262 | CHECK(mod_union_table_.get() != NULL) << "Failed to create mod-union table"; |
Mathieu Chartier | b43b7d4 | 2012-06-19 13:15:09 -0700 | [diff] [blame] | 263 | |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 264 | zygote_mod_union_table_.reset(new ModUnionTableCardCache(this)); |
| 265 | CHECK(zygote_mod_union_table_.get() != NULL) << "Failed to create Zygote mod-union table"; |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 266 | |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 267 | // TODO: Count objects in the image space here. |
Mathieu Chartier | 1cd9c5c | 2012-08-23 10:52:44 -0700 | [diff] [blame] | 268 | num_bytes_allocated_ = 0; |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 269 | |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 270 | // Max stack size in bytes. |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 271 | static const size_t default_mark_stack_size = 64 * KB; |
| 272 | mark_stack_.reset(ObjectStack::Create("dalvik-mark-stack", default_mark_stack_size)); |
| 273 | allocation_stack_.reset(ObjectStack::Create("dalvik-allocation-stack", |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 274 | max_allocation_stack_size_)); |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 275 | live_stack_.reset(ObjectStack::Create("dalvik-live-stack", |
| 276 | max_allocation_stack_size_)); |
Mathieu Chartier | 5301cd2 | 2012-05-31 12:11:36 -0700 | [diff] [blame] | 277 | |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 278 | // It's still too early to take a lock because there are no threads yet, |
Elliott Hughes | 92b3b56 | 2011-09-08 16:32:26 -0700 | [diff] [blame] | 279 | // but we can create the heap lock now. We don't create it earlier to |
| 280 | // make it clear that you can't use locks during heap initialization. |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 281 | gc_complete_lock_ = new Mutex("GC complete lock"); |
Ian Rogers | c604d73 | 2012-10-14 16:09:54 -0700 | [diff] [blame] | 282 | gc_complete_cond_.reset(new ConditionVariable("GC complete condition variable", |
| 283 | *gc_complete_lock_)); |
Brian Carlstrom | 0a5b14d | 2011-09-27 13:29:15 -0700 | [diff] [blame] | 284 | |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 285 | // Set up the cumulative timing loggers. |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 286 | for (size_t i = static_cast<size_t>(kGcTypeSticky); i < static_cast<size_t>(kGcTypeMax); |
| 287 | ++i) { |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 288 | std::ostringstream name; |
| 289 | name << static_cast<GcType>(i); |
| 290 | cumulative_timings_.Put(static_cast<GcType>(i), |
| 291 | new CumulativeLogger(name.str().c_str(), true)); |
| 292 | } |
| 293 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 294 | if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) { |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 295 | LOG(INFO) << "Heap() exiting"; |
Brian Carlstrom | 0a5b14d | 2011-09-27 13:29:15 -0700 | [diff] [blame] | 296 | } |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 297 | } |
| 298 | |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 299 | // Sort spaces based on begin address |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 300 | struct SpaceSorter { |
| 301 | bool operator ()(const ContinuousSpace* a, const ContinuousSpace* b) const { |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 302 | return a->Begin() < b->Begin(); |
| 303 | } |
| 304 | }; |
| 305 | |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 306 | void Heap::AddSpace(ContinuousSpace* space) { |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 307 | WriterMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_); |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 308 | DCHECK(space != NULL); |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 309 | DCHECK(space->GetLiveBitmap() != NULL); |
| 310 | live_bitmap_->AddSpaceBitmap(space->GetLiveBitmap()); |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 311 | DCHECK(space->GetMarkBitmap() != NULL); |
| 312 | mark_bitmap_->AddSpaceBitmap(space->GetMarkBitmap()); |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 313 | spaces_.push_back(space); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 314 | if (space->IsAllocSpace()) { |
| 315 | alloc_space_ = space->AsAllocSpace(); |
| 316 | } |
| 317 | |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 318 | // Ensure that spaces remain sorted in increasing order of start address (required for CMS finger) |
| 319 | std::sort(spaces_.begin(), spaces_.end(), SpaceSorter()); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 320 | |
| 321 | // Ensure that ImageSpaces < ZygoteSpaces < AllocSpaces so that we can do address based checks to |
| 322 | // avoid redundant marking. |
| 323 | bool seen_zygote = false, seen_alloc = false; |
| 324 | for (Spaces::const_iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
| 325 | Space* space = *it; |
| 326 | if (space->IsImageSpace()) { |
| 327 | DCHECK(!seen_zygote); |
| 328 | DCHECK(!seen_alloc); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 329 | } else if (space->IsZygoteSpace()) { |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 330 | DCHECK(!seen_alloc); |
| 331 | seen_zygote = true; |
| 332 | } else if (space->IsAllocSpace()) { |
| 333 | seen_alloc = true; |
| 334 | } |
| 335 | } |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 336 | } |
| 337 | |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 338 | void Heap::DumpGcPerformanceInfo() { |
| 339 | // Dump cumulative timings. |
| 340 | LOG(INFO) << "Dumping cumulative Gc timings"; |
| 341 | uint64_t total_duration = 0; |
| 342 | for (CumulativeTimings::iterator it = cumulative_timings_.begin(); |
| 343 | it != cumulative_timings_.end(); ++it) { |
| 344 | CumulativeLogger* logger = it->second; |
| 345 | if (logger->GetTotalNs() != 0) { |
| 346 | logger->Dump(); |
| 347 | total_duration += logger->GetTotalNs(); |
| 348 | } |
| 349 | } |
| 350 | uint64_t allocation_time = static_cast<uint64_t>(total_allocation_time_) * kTimeAdjust; |
| 351 | size_t total_objects_allocated = GetTotalObjectsAllocated(); |
| 352 | size_t total_bytes_allocated = GetTotalBytesAllocated(); |
| 353 | if (total_duration != 0) { |
| 354 | const double total_seconds = double(total_duration / 1000) / 1000000.0; |
| 355 | LOG(INFO) << "Total time spent in GC: " << PrettyDuration(total_duration); |
| 356 | LOG(INFO) << "Mean GC size throughput: " |
| 357 | << PrettySize(GetTotalBytesFreed() / total_seconds) << "/s"; |
| 358 | LOG(INFO) << "Mean GC object throughput: " << GetTotalObjectsFreed() / total_seconds << "/s"; |
| 359 | } |
| 360 | LOG(INFO) << "Total number of allocations: " << total_objects_allocated; |
| 361 | LOG(INFO) << "Total bytes allocated " << PrettySize(total_bytes_allocated); |
| 362 | if (measure_allocation_time_) { |
| 363 | LOG(INFO) << "Total time spent allocating: " << PrettyDuration(allocation_time); |
| 364 | LOG(INFO) << "Mean allocation time: " |
| 365 | << PrettyDuration(allocation_time / total_objects_allocated); |
| 366 | } |
| 367 | LOG(INFO) << "Total mutator paused time: " << PrettyDuration(total_paused_time_); |
| 368 | LOG(INFO) << "Total waiting for Gc to complete time: " << PrettyDuration(total_wait_time_); |
| 369 | } |
| 370 | |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 371 | Heap::~Heap() { |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 372 | // If we don't reset then the mark stack complains in it's destructor. |
| 373 | allocation_stack_->Reset(); |
| 374 | live_stack_->Reset(); |
| 375 | |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 376 | VLOG(heap) << "~Heap()"; |
Elliott Hughes | b3e66df | 2012-01-12 14:49:18 -0800 | [diff] [blame] | 377 | // We can't take the heap lock here because there might be a daemon thread suspended with the |
| 378 | // heap lock held. We know though that no non-daemon threads are executing, and we know that |
| 379 | // all daemon threads are suspended, and we also know that the threads list have been deleted, so |
| 380 | // those threads can't resume. We're the only running thread, and we can do whatever we like... |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 381 | STLDeleteElements(&spaces_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 382 | delete gc_complete_lock_; |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 383 | STLDeleteValues(&cumulative_timings_); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 384 | } |
| 385 | |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 386 | ContinuousSpace* Heap::FindSpaceFromObject(const Object* obj) const { |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 387 | // TODO: C++0x auto |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 388 | for (Spaces::const_iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
| 389 | if ((*it)->Contains(obj)) { |
| 390 | return *it; |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 391 | } |
| 392 | } |
| 393 | LOG(FATAL) << "object " << reinterpret_cast<const void*>(obj) << " not inside any spaces!"; |
| 394 | return NULL; |
| 395 | } |
| 396 | |
| 397 | ImageSpace* Heap::GetImageSpace() { |
| 398 | // TODO: C++0x auto |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 399 | for (Spaces::const_iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
| 400 | if ((*it)->IsImageSpace()) { |
| 401 | return (*it)->AsImageSpace(); |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 402 | } |
| 403 | } |
| 404 | return NULL; |
| 405 | } |
| 406 | |
Mathieu Chartier | 1c23e1e | 2012-10-12 14:14:11 -0700 | [diff] [blame] | 407 | DlMallocSpace* Heap::GetAllocSpace() { |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 408 | return alloc_space_; |
| 409 | } |
| 410 | |
Elliott Hughes | 8a8b9cb | 2012-04-13 18:29:22 -0700 | [diff] [blame] | 411 | static void MSpaceChunkCallback(void* start, void* end, size_t used_bytes, void* arg) { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 412 | size_t chunk_size = reinterpret_cast<uint8_t*>(end) - reinterpret_cast<uint8_t*>(start); |
Elliott Hughes | 8a8b9cb | 2012-04-13 18:29:22 -0700 | [diff] [blame] | 413 | if (used_bytes < chunk_size) { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 414 | size_t chunk_free_bytes = chunk_size - used_bytes; |
| 415 | size_t& max_contiguous_allocation = *reinterpret_cast<size_t*>(arg); |
| 416 | max_contiguous_allocation = std::max(max_contiguous_allocation, chunk_free_bytes); |
Elliott Hughes | 8a8b9cb | 2012-04-13 18:29:22 -0700 | [diff] [blame] | 417 | } |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 418 | } |
| 419 | |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 420 | Object* Heap::AllocObject(Thread* self, Class* c, size_t byte_count) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 421 | DCHECK(c == NULL || (c->IsClassClass() && byte_count >= sizeof(Class)) || |
| 422 | (c->IsVariableSize() || c->GetObjectSize() == byte_count) || |
| 423 | strlen(ClassHelper(c).GetDescriptor()) == 0); |
| 424 | DCHECK_GE(byte_count, sizeof(Object)); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 425 | |
| 426 | Object* obj = NULL; |
| 427 | size_t size = 0; |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 428 | uint64_t allocation_start = 0; |
| 429 | if (measure_allocation_time_) { |
| 430 | allocation_start = NanoTime(); |
| 431 | } |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 432 | |
| 433 | // We need to have a zygote space or else our newly allocated large object can end up in the |
| 434 | // Zygote resulting in it being prematurely freed. |
| 435 | // We can only do this for primive objects since large objects will not be within the card table |
| 436 | // range. This also means that we rely on SetClass not dirtying the object's card. |
| 437 | if (byte_count >= large_object_threshold_ && have_zygote_space_ && c->IsPrimitiveArray()) { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 438 | size = RoundUp(byte_count, kPageSize); |
Mathieu Chartier | 1c23e1e | 2012-10-12 14:14:11 -0700 | [diff] [blame] | 439 | obj = Allocate(self, large_object_space_.get(), size); |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 440 | // Make sure that our large object didn't get placed anywhere within the space interval or else |
| 441 | // it breaks the immune range. |
| 442 | DCHECK(obj == NULL || |
| 443 | reinterpret_cast<byte*>(obj) < spaces_.front()->Begin() || |
| 444 | reinterpret_cast<byte*>(obj) >= spaces_.back()->End()); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 445 | } else { |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 446 | obj = Allocate(self, alloc_space_, byte_count); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 447 | |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 448 | // Ensure that we did not allocate into a zygote space. |
| 449 | DCHECK(obj == NULL || !have_zygote_space_ || !FindSpaceFromObject(obj)->IsZygoteSpace()); |
| 450 | size = alloc_space_->AllocationSize(obj); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 451 | } |
| 452 | |
Mathieu Chartier | 037813d | 2012-08-23 16:44:59 -0700 | [diff] [blame] | 453 | if (LIKELY(obj != NULL)) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 454 | obj->SetClass(c); |
Mathieu Chartier | 037813d | 2012-08-23 16:44:59 -0700 | [diff] [blame] | 455 | |
| 456 | // Record allocation after since we want to use the atomic add for the atomic fence to guard |
| 457 | // the SetClass since we do not want the class to appear NULL in another thread. |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 458 | RecordAllocation(size, obj); |
Mathieu Chartier | 037813d | 2012-08-23 16:44:59 -0700 | [diff] [blame] | 459 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 460 | if (Dbg::IsAllocTrackingEnabled()) { |
| 461 | Dbg::RecordAllocation(c, byte_count); |
Elliott Hughes | 418dfe7 | 2011-10-06 18:56:27 -0700 | [diff] [blame] | 462 | } |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 463 | if (static_cast<size_t>(num_bytes_allocated_) >= concurrent_start_bytes_) { |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 464 | // We already have a request pending, no reason to start more until we update |
| 465 | // concurrent_start_bytes_. |
| 466 | concurrent_start_bytes_ = std::numeric_limits<size_t>::max(); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 467 | // The SirtRef is necessary since the calls in RequestConcurrentGC are a safepoint. |
Ian Rogers | 1f53934 | 2012-10-03 21:09:42 -0700 | [diff] [blame] | 468 | SirtRef<Object> ref(self, obj); |
| 469 | RequestConcurrentGC(self); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 470 | } |
| 471 | VerifyObject(obj); |
| 472 | |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 473 | if (measure_allocation_time_) { |
| 474 | total_allocation_time_ += (NanoTime() - allocation_start) / kTimeAdjust; |
| 475 | } |
| 476 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 477 | return obj; |
| 478 | } |
Mathieu Chartier | 037813d | 2012-08-23 16:44:59 -0700 | [diff] [blame] | 479 | int64_t total_bytes_free = GetFreeMemory(); |
| 480 | size_t max_contiguous_allocation = 0; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 481 | // TODO: C++0x auto |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 482 | for (Spaces::const_iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
| 483 | if ((*it)->IsAllocSpace()) { |
| 484 | (*it)->AsAllocSpace()->Walk(MSpaceChunkCallback, &max_contiguous_allocation); |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 485 | } |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 486 | } |
Elliott Hughes | 418dfe7 | 2011-10-06 18:56:27 -0700 | [diff] [blame] | 487 | |
Elliott Hughes | 8a8b9cb | 2012-04-13 18:29:22 -0700 | [diff] [blame] | 488 | std::string msg(StringPrintf("Failed to allocate a %zd-byte %s (%lld total bytes free; largest possible contiguous allocation %zd bytes)", |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 489 | byte_count, PrettyDescriptor(c).c_str(), total_bytes_free, max_contiguous_allocation)); |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 490 | self->ThrowOutOfMemoryError(msg.c_str()); |
Elliott Hughes | 418dfe7 | 2011-10-06 18:56:27 -0700 | [diff] [blame] | 491 | return NULL; |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 492 | } |
| 493 | |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 494 | bool Heap::IsHeapAddress(const Object* obj) { |
Elliott Hughes | 92b3b56 | 2011-09-08 16:32:26 -0700 | [diff] [blame] | 495 | // Note: we deliberately don't take the lock here, and mustn't test anything that would |
| 496 | // require taking the lock. |
Elliott Hughes | 88c5c35 | 2012-03-15 18:49:48 -0700 | [diff] [blame] | 497 | if (obj == NULL) { |
| 498 | return true; |
| 499 | } |
| 500 | if (!IsAligned<kObjectAlignment>(obj)) { |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 501 | return false; |
| 502 | } |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 503 | for (size_t i = 0; i < spaces_.size(); ++i) { |
Ian Rogers | 30fab40 | 2012-01-23 15:43:46 -0800 | [diff] [blame] | 504 | if (spaces_[i]->Contains(obj)) { |
| 505 | return true; |
| 506 | } |
| 507 | } |
Mathieu Chartier | 0b0b515 | 2012-10-15 13:53:46 -0700 | [diff] [blame] | 508 | // Note: Doing this only works for the free list version of the large object space since the |
| 509 | // multiple memory map version uses a lock to do the contains check. |
| 510 | return large_object_space_->Contains(obj); |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 511 | } |
| 512 | |
Elliott Hughes | 6a5bd49 | 2011-10-28 14:33:57 -0700 | [diff] [blame] | 513 | bool Heap::IsLiveObjectLocked(const Object* obj) { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 514 | Locks::heap_bitmap_lock_->AssertReaderHeld(Thread::Current()); |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 515 | return IsHeapAddress(obj) && GetLiveBitmap()->Test(obj); |
Elliott Hughes | 6a5bd49 | 2011-10-28 14:33:57 -0700 | [diff] [blame] | 516 | } |
| 517 | |
Elliott Hughes | 3e465b1 | 2011-09-02 18:26:12 -0700 | [diff] [blame] | 518 | #if VERIFY_OBJECT_ENABLED |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 519 | void Heap::VerifyObject(const Object* obj) { |
jeffhao | 4eb68ed | 2012-10-17 16:41:07 -0700 | [diff] [blame] | 520 | if (obj == NULL || this == NULL || !verify_objects_ || Thread::Current() == NULL || |
jeffhao | 2504552 | 2012-03-13 19:34:37 -0700 | [diff] [blame] | 521 | Runtime::Current()->GetThreadList()->GetLockOwner() == Thread::Current()->GetTid()) { |
Elliott Hughes | 85d1545 | 2011-09-16 17:33:01 -0700 | [diff] [blame] | 522 | return; |
| 523 | } |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 524 | VerifyObjectBody(obj); |
Elliott Hughes | 92b3b56 | 2011-09-08 16:32:26 -0700 | [diff] [blame] | 525 | } |
| 526 | #endif |
| 527 | |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 528 | void Heap::DumpSpaces() { |
| 529 | // TODO: C++0x auto |
| 530 | for (Spaces::iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 531 | ContinuousSpace* space = *it; |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 532 | SpaceBitmap* live_bitmap = space->GetLiveBitmap(); |
| 533 | SpaceBitmap* mark_bitmap = space->GetMarkBitmap(); |
| 534 | LOG(INFO) << space << " " << *space << "\n" |
| 535 | << live_bitmap << " " << *live_bitmap << "\n" |
| 536 | << mark_bitmap << " " << *mark_bitmap; |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 537 | } |
Mathieu Chartier | 128c52c | 2012-10-16 14:12:41 -0700 | [diff] [blame] | 538 | if (large_object_space_.get() != NULL) { |
| 539 | large_object_space_->Dump(LOG(INFO)); |
| 540 | } |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 541 | } |
| 542 | |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 543 | void Heap::VerifyObjectBody(const Object* obj) { |
Mathieu Chartier | dcf8d72 | 2012-08-02 14:55:54 -0700 | [diff] [blame] | 544 | if (!IsAligned<kObjectAlignment>(obj)) { |
| 545 | LOG(FATAL) << "Object isn't aligned: " << obj; |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 546 | } |
| 547 | |
Ian Rogers | f0bbeab | 2012-10-10 18:26:27 -0700 | [diff] [blame] | 548 | // TODO: the bitmap tests below are racy if VerifyObjectBody is called without the |
| 549 | // heap_bitmap_lock_. |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 550 | if (!GetLiveBitmap()->Test(obj)) { |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 551 | // Check the allocation stack / live stack. |
| 552 | if (!std::binary_search(live_stack_->Begin(), live_stack_->End(), obj) && |
| 553 | std::find(allocation_stack_->Begin(), allocation_stack_->End(), obj) == |
| 554 | allocation_stack_->End()) { |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 555 | if (large_object_space_->GetLiveObjects()->Test(obj)) { |
| 556 | DumpSpaces(); |
| 557 | LOG(FATAL) << "Object is dead: " << obj; |
| 558 | } |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 559 | } |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 560 | } |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 561 | |
Mathieu Chartier | dcf8d72 | 2012-08-02 14:55:54 -0700 | [diff] [blame] | 562 | // Ignore early dawn of the universe verifications |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 563 | if (!VERIFY_OBJECT_FAST && GetObjectsAllocated() > 10) { |
Mathieu Chartier | dcf8d72 | 2012-08-02 14:55:54 -0700 | [diff] [blame] | 564 | const byte* raw_addr = reinterpret_cast<const byte*>(obj) + |
| 565 | Object::ClassOffset().Int32Value(); |
| 566 | const Class* c = *reinterpret_cast<Class* const *>(raw_addr); |
| 567 | if (c == NULL) { |
| 568 | LOG(FATAL) << "Null class in object: " << obj; |
| 569 | } else if (!IsAligned<kObjectAlignment>(c)) { |
| 570 | LOG(FATAL) << "Class isn't aligned: " << c << " in object: " << obj; |
| 571 | } else if (!GetLiveBitmap()->Test(c)) { |
| 572 | LOG(FATAL) << "Class of object is dead: " << c << " in object: " << obj; |
| 573 | } |
| 574 | // Check obj.getClass().getClass() == obj.getClass().getClass().getClass() |
| 575 | // Note: we don't use the accessors here as they have internal sanity checks |
| 576 | // that we don't want to run |
| 577 | raw_addr = reinterpret_cast<const byte*>(c) + Object::ClassOffset().Int32Value(); |
| 578 | const Class* c_c = *reinterpret_cast<Class* const *>(raw_addr); |
| 579 | raw_addr = reinterpret_cast<const byte*>(c_c) + Object::ClassOffset().Int32Value(); |
| 580 | const Class* c_c_c = *reinterpret_cast<Class* const *>(raw_addr); |
| 581 | CHECK_EQ(c_c, c_c_c); |
| 582 | } |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 583 | } |
| 584 | |
Brian Carlstrom | 78128a6 | 2011-09-15 17:21:19 -0700 | [diff] [blame] | 585 | void Heap::VerificationCallback(Object* obj, void* arg) { |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 586 | DCHECK(obj != NULL); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 587 | reinterpret_cast<Heap*>(arg)->VerifyObjectBody(obj); |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 588 | } |
| 589 | |
| 590 | void Heap::VerifyHeap() { |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 591 | ReaderMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_); |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 592 | GetLiveBitmap()->Walk(Heap::VerificationCallback, this); |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 593 | } |
| 594 | |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 595 | void Heap::RecordAllocation(size_t size, Object* obj) { |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 596 | DCHECK(obj != NULL); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 597 | DCHECK_GT(size, 0u); |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 598 | num_bytes_allocated_ += size; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 599 | |
| 600 | if (Runtime::Current()->HasStatsEnabled()) { |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 601 | RuntimeStats* thread_stats = Thread::Current()->GetStats(); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 602 | ++thread_stats->allocated_objects; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 603 | thread_stats->allocated_bytes += size; |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 604 | |
| 605 | // TODO: Update these atomically. |
| 606 | RuntimeStats* global_stats = Runtime::Current()->GetStats(); |
| 607 | ++global_stats->allocated_objects; |
| 608 | global_stats->allocated_bytes += size; |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 609 | } |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 610 | |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 611 | // This is safe to do since the GC will never free objects which are neither in the allocation |
| 612 | // stack or the live bitmap. |
| 613 | while (!allocation_stack_->AtomicPushBack(obj)) { |
| 614 | Thread* self = Thread::Current(); |
| 615 | self->TransitionFromRunnableToSuspended(kWaitingPerformingGc); |
| 616 | // If we actually ran a different type of Gc than requested, we can skip the index forwards. |
| 617 | CollectGarbageInternal(kGcTypeSticky, kGcCauseForAlloc, false); |
| 618 | self->TransitionFromSuspendedToRunnable(); |
| 619 | } |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 620 | } |
| 621 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 622 | void Heap::RecordFree(size_t freed_objects, size_t freed_bytes) { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 623 | DCHECK_LE(freed_bytes, static_cast<size_t>(num_bytes_allocated_)); |
| 624 | num_bytes_allocated_ -= freed_bytes; |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 625 | |
| 626 | if (Runtime::Current()->HasStatsEnabled()) { |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 627 | RuntimeStats* thread_stats = Thread::Current()->GetStats(); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 628 | thread_stats->freed_objects += freed_objects; |
Elliott Hughes | 307f75d | 2011-10-12 18:04:40 -0700 | [diff] [blame] | 629 | thread_stats->freed_bytes += freed_bytes; |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 630 | |
| 631 | // TODO: Do this concurrently. |
| 632 | RuntimeStats* global_stats = Runtime::Current()->GetStats(); |
| 633 | global_stats->freed_objects += freed_objects; |
| 634 | global_stats->freed_bytes += freed_bytes; |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 635 | } |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 636 | } |
| 637 | |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 638 | Object* Heap::TryToAllocate(Thread* self, AllocSpace* space, size_t alloc_size, bool grow) { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 639 | // Should we try to use a CAS here and fix up num_bytes_allocated_ later with AllocationSize? |
Mathieu Chartier | 1c23e1e | 2012-10-12 14:14:11 -0700 | [diff] [blame] | 640 | if (enforce_heap_growth_rate_ && num_bytes_allocated_ + alloc_size > max_allowed_footprint_) { |
| 641 | if (grow) { |
| 642 | // Grow the heap by alloc_size extra bytes. |
| 643 | max_allowed_footprint_ = std::min(max_allowed_footprint_ + alloc_size, growth_limit_); |
| 644 | VLOG(gc) << "Grow heap to " << PrettySize(max_allowed_footprint_) |
| 645 | << " for a " << PrettySize(alloc_size) << " allocation"; |
| 646 | } else { |
| 647 | return NULL; |
| 648 | } |
| 649 | } |
| 650 | |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 651 | if (num_bytes_allocated_ + alloc_size > growth_limit_) { |
Mathieu Chartier | 1c23e1e | 2012-10-12 14:14:11 -0700 | [diff] [blame] | 652 | // Completely out of memory. |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 653 | return NULL; |
| 654 | } |
| 655 | |
Mathieu Chartier | 1c23e1e | 2012-10-12 14:14:11 -0700 | [diff] [blame] | 656 | return space->Alloc(self, alloc_size); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 657 | } |
| 658 | |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 659 | Object* Heap::Allocate(Thread* self, AllocSpace* space, size_t alloc_size) { |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 660 | // Since allocation can cause a GC which will need to SuspendAll, make sure all allocations are |
| 661 | // done in the runnable state where suspension is expected. |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 662 | DCHECK_EQ(self->GetState(), kRunnable); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 663 | self->AssertThreadSuspensionIsAllowable(); |
Brian Carlstrom | b82b687 | 2011-10-26 17:18:07 -0700 | [diff] [blame] | 664 | |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 665 | Object* ptr = TryToAllocate(self, space, alloc_size, false); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 666 | if (ptr != NULL) { |
| 667 | return ptr; |
| 668 | } |
| 669 | |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 670 | // The allocation failed. If the GC is running, block until it completes, and then retry the |
| 671 | // allocation. |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 672 | GcType last_gc = WaitForConcurrentGcToComplete(self); |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 673 | if (last_gc != kGcTypeNone) { |
| 674 | // A GC was in progress and we blocked, retry allocation now that memory has been freed. |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 675 | ptr = TryToAllocate(self, space, alloc_size, false); |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 676 | if (ptr != NULL) { |
| 677 | return ptr; |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 678 | } |
| 679 | } |
| 680 | |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 681 | // Loop through our different Gc types and try to Gc until we get enough free memory. |
| 682 | for (size_t i = static_cast<size_t>(last_gc) + 1; i < static_cast<size_t>(kGcTypeMax); ++i) { |
| 683 | bool run_gc = false; |
| 684 | GcType gc_type = static_cast<GcType>(i); |
| 685 | switch (gc_type) { |
| 686 | case kGcTypeSticky: { |
| 687 | const size_t alloc_space_size = alloc_space_->Size(); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 688 | run_gc = alloc_space_size > min_alloc_space_size_for_sticky_gc_ && |
| 689 | alloc_space_->Capacity() - alloc_space_size >= min_remaining_space_for_sticky_gc_; |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 690 | break; |
| 691 | } |
| 692 | case kGcTypePartial: |
| 693 | run_gc = have_zygote_space_; |
| 694 | break; |
| 695 | case kGcTypeFull: |
| 696 | run_gc = true; |
| 697 | break; |
| 698 | default: |
| 699 | break; |
| 700 | } |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 701 | |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 702 | if (run_gc) { |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 703 | self->TransitionFromRunnableToSuspended(kWaitingPerformingGc); |
| 704 | |
| 705 | // If we actually ran a different type of Gc than requested, we can skip the index forwards. |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 706 | GcType gc_type_ran = CollectGarbageInternal(gc_type, kGcCauseForAlloc, false); |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 707 | DCHECK(static_cast<size_t>(gc_type_ran) >= i); |
| 708 | i = static_cast<size_t>(gc_type_ran); |
| 709 | self->TransitionFromSuspendedToRunnable(); |
| 710 | |
| 711 | // Did we free sufficient memory for the allocation to succeed? |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 712 | ptr = TryToAllocate(self, space, alloc_size, false); |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 713 | if (ptr != NULL) { |
| 714 | return ptr; |
| 715 | } |
| 716 | } |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 717 | } |
| 718 | |
| 719 | // Allocations have failed after GCs; this is an exceptional state. |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 720 | // Try harder, growing the heap if necessary. |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 721 | ptr = TryToAllocate(self, space, alloc_size, true); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 722 | if (ptr != NULL) { |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 723 | return ptr; |
| 724 | } |
| 725 | |
Elliott Hughes | 81ff318 | 2012-03-23 20:35:56 -0700 | [diff] [blame] | 726 | // Most allocations should have succeeded by now, so the heap is really full, really fragmented, |
| 727 | // or the requested size is really big. Do another GC, collecting SoftReferences this time. The |
| 728 | // VM spec requires that all SoftReferences have been collected and cleared before throwing OOME. |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 729 | |
Elliott Hughes | 418dfe7 | 2011-10-06 18:56:27 -0700 | [diff] [blame] | 730 | // OLD-TODO: wait for the finalizers from the previous GC to finish |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 731 | VLOG(gc) << "Forcing collection of SoftReferences for " << PrettySize(alloc_size) |
| 732 | << " allocation"; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 733 | |
Mathieu Chartier | fc8cfac | 2012-06-19 11:56:36 -0700 | [diff] [blame] | 734 | // We don't need a WaitForConcurrentGcToComplete here either. |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 735 | self->TransitionFromRunnableToSuspended(kWaitingPerformingGc); |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 736 | CollectGarbageInternal(kGcTypeFull, kGcCauseForAlloc, true); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 737 | self->TransitionFromSuspendedToRunnable(); |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 738 | return TryToAllocate(self, space, alloc_size, true); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 739 | } |
| 740 | |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 741 | void Heap::SetTargetHeapUtilization(float target) { |
| 742 | DCHECK_GT(target, 0.0f); // asserted in Java code |
| 743 | DCHECK_LT(target, 1.0f); |
| 744 | target_utilization_ = target; |
| 745 | } |
| 746 | |
| 747 | int64_t Heap::GetMaxMemory() const { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 748 | return growth_limit_; |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 749 | } |
| 750 | |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 751 | int64_t Heap::GetTotalMemory() const { |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 752 | return GetMaxMemory(); |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 753 | } |
| 754 | |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 755 | int64_t Heap::GetFreeMemory() const { |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 756 | return GetMaxMemory() - num_bytes_allocated_; |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 757 | } |
| 758 | |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 759 | size_t Heap::GetTotalBytesFreed() const { |
| 760 | return total_bytes_freed_; |
| 761 | } |
| 762 | |
| 763 | size_t Heap::GetTotalObjectsFreed() const { |
| 764 | return total_objects_freed_; |
| 765 | } |
| 766 | |
| 767 | size_t Heap::GetTotalObjectsAllocated() const { |
| 768 | size_t total = large_object_space_->GetTotalObjectsAllocated(); |
| 769 | for (Spaces::const_iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
| 770 | Space* space = *it; |
| 771 | if (space->IsAllocSpace()) { |
| 772 | total += space->AsAllocSpace()->GetTotalObjectsAllocated(); |
| 773 | } |
| 774 | } |
| 775 | return total; |
| 776 | } |
| 777 | |
| 778 | size_t Heap::GetTotalBytesAllocated() const { |
| 779 | size_t total = large_object_space_->GetTotalBytesAllocated(); |
| 780 | for (Spaces::const_iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
| 781 | Space* space = *it; |
| 782 | if (space->IsAllocSpace()) { |
| 783 | total += space->AsAllocSpace()->GetTotalBytesAllocated(); |
| 784 | } |
| 785 | } |
| 786 | return total; |
| 787 | } |
| 788 | |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 789 | class InstanceCounter { |
| 790 | public: |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 791 | InstanceCounter(Class* c, bool count_assignable, size_t* const count) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 792 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 793 | : class_(c), count_assignable_(count_assignable), count_(count) { |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 794 | |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 795 | } |
| 796 | |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 797 | void operator()(const Object* o) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { |
| 798 | const Class* instance_class = o->GetClass(); |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 799 | if (count_assignable_) { |
| 800 | if (instance_class == class_) { |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 801 | ++*count_; |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 802 | } |
| 803 | } else { |
| 804 | if (instance_class != NULL && class_->IsAssignableFrom(instance_class)) { |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 805 | ++*count_; |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 806 | } |
| 807 | } |
| 808 | } |
| 809 | |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 810 | private: |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 811 | Class* class_; |
| 812 | bool count_assignable_; |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 813 | size_t* const count_; |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 814 | }; |
| 815 | |
| 816 | int64_t Heap::CountInstances(Class* c, bool count_assignable) { |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 817 | size_t count = 0; |
| 818 | InstanceCounter counter(c, count_assignable, &count); |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 819 | ReaderMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 820 | GetLiveBitmap()->Visit(counter); |
| 821 | return count; |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 822 | } |
| 823 | |
Ian Rogers | 30fab40 | 2012-01-23 15:43:46 -0800 | [diff] [blame] | 824 | void Heap::CollectGarbage(bool clear_soft_references) { |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 825 | // Even if we waited for a GC we still need to do another GC since weaks allocated during the |
| 826 | // last GC will not have necessarily been cleared. |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 827 | Thread* self = Thread::Current(); |
| 828 | WaitForConcurrentGcToComplete(self); |
| 829 | ScopedThreadStateChange tsc(self, kWaitingPerformingGc); |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 830 | // CollectGarbageInternal(have_zygote_space_ ? kGcTypePartial : kGcTypeFull, clear_soft_references); |
| 831 | CollectGarbageInternal(kGcTypeFull, kGcCauseExplicit, clear_soft_references); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 832 | } |
| 833 | |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 834 | void Heap::PreZygoteFork() { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 835 | static Mutex zygote_creation_lock_("zygote creation lock", kZygoteCreationLock); |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 836 | Thread* self = Thread::Current(); |
| 837 | MutexLock mu(self, zygote_creation_lock_); |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 838 | |
| 839 | // Try to see if we have any Zygote spaces. |
| 840 | if (have_zygote_space_) { |
| 841 | return; |
| 842 | } |
| 843 | |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 844 | VLOG(heap) << "Starting PreZygoteFork with alloc space size " << PrettySize(alloc_space_->Size()); |
| 845 | |
| 846 | { |
| 847 | // Flush the alloc stack. |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 848 | WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 849 | FlushAllocStack(); |
| 850 | } |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 851 | |
| 852 | // Replace the first alloc space we find with a zygote space. |
| 853 | // TODO: C++0x auto |
| 854 | for (Spaces::iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
| 855 | if ((*it)->IsAllocSpace()) { |
Mathieu Chartier | 1c23e1e | 2012-10-12 14:14:11 -0700 | [diff] [blame] | 856 | DlMallocSpace* zygote_space = (*it)->AsAllocSpace(); |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 857 | |
| 858 | // Turns the current alloc space into a Zygote space and obtain the new alloc space composed |
| 859 | // of the remaining available heap memory. |
| 860 | alloc_space_ = zygote_space->CreateZygoteSpace(); |
Mathieu Chartier | 1c23e1e | 2012-10-12 14:14:11 -0700 | [diff] [blame] | 861 | alloc_space_->SetFootprintLimit(alloc_space_->Capacity()); |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 862 | |
| 863 | // Change the GC retention policy of the zygote space to only collect when full. |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 864 | zygote_space->SetGcRetentionPolicy(kGcRetentionPolicyFullCollect); |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 865 | AddSpace(alloc_space_); |
| 866 | have_zygote_space_ = true; |
| 867 | break; |
| 868 | } |
| 869 | } |
Mathieu Chartier | 1cd9c5c | 2012-08-23 10:52:44 -0700 | [diff] [blame] | 870 | |
Ian Rogers | 5f5a2c0 | 2012-09-17 10:52:08 -0700 | [diff] [blame] | 871 | // Reset the cumulative loggers since we now have a few additional timing phases. |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 872 | // TODO: C++0x |
| 873 | for (CumulativeTimings::iterator it = cumulative_timings_.begin(); |
| 874 | it != cumulative_timings_.end(); ++it) { |
| 875 | it->second->Reset(); |
| 876 | } |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 877 | } |
| 878 | |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 879 | void Heap::FlushAllocStack() { |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 880 | MarkAllocStack(alloc_space_->GetLiveBitmap(), large_object_space_->GetLiveObjects(), |
| 881 | allocation_stack_.get()); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 882 | allocation_stack_->Reset(); |
| 883 | } |
| 884 | |
Mathieu Chartier | 1cd9c5c | 2012-08-23 10:52:44 -0700 | [diff] [blame] | 885 | size_t Heap::GetUsedMemorySize() const { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 886 | return num_bytes_allocated_; |
Mathieu Chartier | 1cd9c5c | 2012-08-23 10:52:44 -0700 | [diff] [blame] | 887 | } |
| 888 | |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 889 | void Heap::MarkAllocStack(SpaceBitmap* bitmap, SpaceSetMap* large_objects, ObjectStack* stack) { |
| 890 | Object** limit = stack->End(); |
| 891 | for (Object** it = stack->Begin(); it != limit; ++it) { |
| 892 | const Object* obj = *it; |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 893 | DCHECK(obj != NULL); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 894 | if (LIKELY(bitmap->HasAddress(obj))) { |
| 895 | bitmap->Set(obj); |
| 896 | } else { |
| 897 | large_objects->Set(obj); |
| 898 | } |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 899 | } |
| 900 | } |
| 901 | |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 902 | void Heap::UnMarkAllocStack(SpaceBitmap* bitmap, SpaceSetMap* large_objects, ObjectStack* stack) { |
| 903 | Object** limit = stack->End(); |
| 904 | for (Object** it = stack->Begin(); it != limit; ++it) { |
| 905 | const Object* obj = *it; |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 906 | DCHECK(obj != NULL); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 907 | if (LIKELY(bitmap->HasAddress(obj))) { |
| 908 | bitmap->Clear(obj); |
| 909 | } else { |
| 910 | large_objects->Clear(obj); |
| 911 | } |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 912 | } |
| 913 | } |
| 914 | |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 915 | GcType Heap::CollectGarbageInternal(GcType gc_type, GcCause gc_cause, bool clear_soft_references) { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 916 | Thread* self = Thread::Current(); |
| 917 | Locks::mutator_lock_->AssertNotHeld(self); |
| 918 | DCHECK_EQ(self->GetState(), kWaitingPerformingGc); |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 919 | |
Ian Rogers | 120f1c7 | 2012-09-28 17:17:10 -0700 | [diff] [blame] | 920 | if (self->IsHandlingStackOverflow()) { |
| 921 | LOG(WARNING) << "Performing GC on a thread that is handling a stack overflow."; |
| 922 | } |
| 923 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 924 | // Ensure there is only one GC at a time. |
| 925 | bool start_collect = false; |
| 926 | while (!start_collect) { |
| 927 | { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 928 | MutexLock mu(self, *gc_complete_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 929 | if (!is_gc_running_) { |
| 930 | is_gc_running_ = true; |
| 931 | start_collect = true; |
| 932 | } |
| 933 | } |
| 934 | if (!start_collect) { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 935 | WaitForConcurrentGcToComplete(self); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 936 | // TODO: if another thread beat this one to do the GC, perhaps we should just return here? |
| 937 | // Not doing at the moment to ensure soft references are cleared. |
| 938 | } |
| 939 | } |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 940 | gc_complete_lock_->AssertNotHeld(self); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 941 | |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 942 | if (gc_cause == kGcCauseForAlloc && Runtime::Current()->HasStatsEnabled()) { |
| 943 | ++Runtime::Current()->GetStats()->gc_for_alloc_count; |
| 944 | ++Thread::Current()->GetStats()->gc_for_alloc_count; |
| 945 | } |
| 946 | |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 947 | // We need to do partial GCs every now and then to avoid the heap growing too much and |
| 948 | // fragmenting. |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 949 | if (gc_type == kGcTypeSticky && ++sticky_gc_count_ > partial_gc_frequency_) { |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 950 | gc_type = kGcTypePartial; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 951 | } |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 952 | if (gc_type != kGcTypeSticky) { |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 953 | sticky_gc_count_ = 0; |
| 954 | } |
| 955 | |
Mathieu Chartier | 637e348 | 2012-08-17 10:41:32 -0700 | [diff] [blame] | 956 | if (concurrent_gc_) { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 957 | CollectGarbageConcurrentMarkSweepPlan(self, gc_type, gc_cause, clear_soft_references); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 958 | } else { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 959 | CollectGarbageMarkSweepPlan(self, gc_type, gc_cause, clear_soft_references); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 960 | } |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 961 | bytes_since_last_gc_ = 0; |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 962 | |
Ian Rogers | 15bf2d3 | 2012-08-28 17:33:04 -0700 | [diff] [blame] | 963 | { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 964 | MutexLock mu(self, *gc_complete_lock_); |
Ian Rogers | 15bf2d3 | 2012-08-28 17:33:04 -0700 | [diff] [blame] | 965 | is_gc_running_ = false; |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 966 | last_gc_type_ = gc_type; |
Ian Rogers | 15bf2d3 | 2012-08-28 17:33:04 -0700 | [diff] [blame] | 967 | // Wake anyone who may have been waiting for the GC to complete. |
Ian Rogers | c604d73 | 2012-10-14 16:09:54 -0700 | [diff] [blame] | 968 | gc_complete_cond_->Broadcast(self); |
Ian Rogers | 15bf2d3 | 2012-08-28 17:33:04 -0700 | [diff] [blame] | 969 | } |
| 970 | // Inform DDMS that a GC completed. |
| 971 | Dbg::GcDidFinish(); |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 972 | return gc_type; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 973 | } |
Mathieu Chartier | a639903 | 2012-06-11 18:49:50 -0700 | [diff] [blame] | 974 | |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 975 | void Heap::CollectGarbageMarkSweepPlan(Thread* self, GcType gc_type, GcCause gc_cause, |
| 976 | bool clear_soft_references) { |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 977 | TimingLogger timings("CollectGarbageInternal", true); |
Mathieu Chartier | 662618f | 2012-06-06 12:01:47 -0700 | [diff] [blame] | 978 | |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 979 | std::stringstream gc_type_str; |
| 980 | gc_type_str << gc_type << " "; |
| 981 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 982 | // Suspend all threads are get exclusive access to the heap. |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 983 | uint64_t start_time = NanoTime(); |
Elliott Hughes | 8d768a9 | 2011-09-14 16:35:25 -0700 | [diff] [blame] | 984 | ThreadList* thread_list = Runtime::Current()->GetThreadList(); |
| 985 | thread_list->SuspendAll(); |
Mathieu Chartier | 662618f | 2012-06-06 12:01:47 -0700 | [diff] [blame] | 986 | timings.AddSplit("SuspendAll"); |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 987 | Locks::mutator_lock_->AssertExclusiveHeld(self); |
Elliott Hughes | 83df2ac | 2011-10-11 16:37:54 -0700 | [diff] [blame] | 988 | |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 989 | size_t bytes_freed = 0; |
Elliott Hughes | adb460d | 2011-10-05 17:02:34 -0700 | [diff] [blame] | 990 | Object* cleared_references = NULL; |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 991 | { |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 992 | MarkSweep mark_sweep(mark_stack_.get()); |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 993 | mark_sweep.Init(); |
Elliott Hughes | 307f75d | 2011-10-12 18:04:40 -0700 | [diff] [blame] | 994 | timings.AddSplit("Init"); |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 995 | |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 996 | if (verify_pre_gc_heap_) { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 997 | WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 998 | if (!VerifyHeapReferences()) { |
| 999 | LOG(FATAL) << "Pre " << gc_type_str.str() << "Gc verification failed"; |
| 1000 | } |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1001 | timings.AddSplit("VerifyHeapReferencesPreGC"); |
| 1002 | } |
| 1003 | |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1004 | // Swap allocation stack and live stack, enabling us to have new allocations during this GC. |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1005 | SwapStacks(); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1006 | |
| 1007 | // We will need to know which cards were dirty for doing concurrent processing of dirty cards. |
| 1008 | // TODO: Investigate using a mark stack instead of a vector. |
| 1009 | std::vector<byte*> dirty_cards; |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1010 | if (gc_type == kGcTypeSticky) { |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1011 | for (Spaces::iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
| 1012 | card_table_->GetDirtyCards(*it, dirty_cards); |
| 1013 | } |
| 1014 | } |
| 1015 | |
Mathieu Chartier | b43b7d4 | 2012-06-19 13:15:09 -0700 | [diff] [blame] | 1016 | // Clear image space cards and keep track of cards we cleared in the mod-union table. |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1017 | ClearCards(timings); |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 1018 | |
Ian Rogers | 120f1c7 | 2012-09-28 17:17:10 -0700 | [diff] [blame] | 1019 | WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1020 | if (gc_type == kGcTypePartial) { |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 1021 | // Copy the mark bits over from the live bits, do this as early as possible or else we can |
| 1022 | // accidentally un-mark roots. |
| 1023 | // Needed for scanning dirty objects. |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1024 | for (Spaces::iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1025 | if ((*it)->GetGcRetentionPolicy() == kGcRetentionPolicyFullCollect) { |
| 1026 | mark_sweep.BindLiveToMarkBitmap(*it); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1027 | } |
| 1028 | } |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1029 | timings.AddSplit("BindLiveToMarked"); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1030 | |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 1031 | // We can assume that everything from the start of the first space to the alloc space is marked. |
| 1032 | mark_sweep.SetImmuneRange(reinterpret_cast<Object*>(spaces_[0]->Begin()), |
| 1033 | reinterpret_cast<Object*>(alloc_space_->Begin())); |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1034 | } else if (gc_type == kGcTypeSticky) { |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 1035 | for (Spaces::iterator it = spaces_.begin();it != spaces_.end(); ++it) { |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1036 | if ((*it)->GetGcRetentionPolicy() != kGcRetentionPolicyNeverCollect) { |
| 1037 | mark_sweep.BindLiveToMarkBitmap(*it); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1038 | } |
| 1039 | } |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1040 | timings.AddSplit("BindLiveToMarkBitmap"); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 1041 | large_object_space_->CopyLiveToMarked(); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1042 | timings.AddSplit("CopyLiveToMarked"); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 1043 | mark_sweep.SetImmuneRange(reinterpret_cast<Object*>(spaces_[0]->Begin()), |
| 1044 | reinterpret_cast<Object*>(alloc_space_->Begin())); |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 1045 | } |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1046 | mark_sweep.FindDefaultMarkBitmap(); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1047 | |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 1048 | mark_sweep.MarkRoots(); |
Mathieu Chartier | 9ebae1f | 2012-10-15 17:38:16 -0700 | [diff] [blame] | 1049 | mark_sweep.MarkConcurrentRoots(); |
Elliott Hughes | 307f75d | 2011-10-12 18:04:40 -0700 | [diff] [blame] | 1050 | timings.AddSplit("MarkRoots"); |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 1051 | |
Mathieu Chartier | b43b7d4 | 2012-06-19 13:15:09 -0700 | [diff] [blame] | 1052 | // Roots are marked on the bitmap and the mark_stack is empty. |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 1053 | DCHECK(mark_stack_->IsEmpty()); |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 1054 | |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1055 | UpdateAndMarkModUnion(&mark_sweep, timings, gc_type); |
| 1056 | |
| 1057 | if (gc_type != kGcTypeSticky) { |
| 1058 | MarkAllocStack(alloc_space_->GetLiveBitmap(), large_object_space_->GetLiveObjects(), |
| 1059 | live_stack_.get()); |
| 1060 | timings.AddSplit("MarkStackAsLive"); |
| 1061 | } |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 1062 | |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1063 | if (verify_mod_union_table_) { |
| 1064 | zygote_mod_union_table_->Update(); |
| 1065 | zygote_mod_union_table_->Verify(); |
| 1066 | mod_union_table_->Update(); |
| 1067 | mod_union_table_->Verify(); |
| 1068 | } |
Mathieu Chartier | b43b7d4 | 2012-06-19 13:15:09 -0700 | [diff] [blame] | 1069 | |
| 1070 | // Recursively mark all the non-image bits set in the mark bitmap. |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1071 | if (gc_type != kGcTypeSticky) { |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1072 | mark_sweep.RecursiveMark(gc_type == kGcTypePartial, timings); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1073 | } else { |
| 1074 | mark_sweep.RecursiveMarkCards(card_table_.get(), dirty_cards, timings); |
| 1075 | } |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1076 | mark_sweep.DisableFinger(); |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 1077 | |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1078 | // Need to process references before the swap since it uses IsMarked. |
Ian Rogers | 30fab40 | 2012-01-23 15:43:46 -0800 | [diff] [blame] | 1079 | mark_sweep.ProcessReferences(clear_soft_references); |
Elliott Hughes | 307f75d | 2011-10-12 18:04:40 -0700 | [diff] [blame] | 1080 | timings.AddSplit("ProcessReferences"); |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 1081 | |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1082 | #ifndef NDEBUG |
Mathieu Chartier | 262e5ff | 2012-06-01 17:35:38 -0700 | [diff] [blame] | 1083 | // Verify that we only reach marked objects from the image space |
| 1084 | mark_sweep.VerifyImageRoots(); |
| 1085 | timings.AddSplit("VerifyImageRoots"); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1086 | #endif |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 1087 | |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1088 | if (gc_type != kGcTypeSticky) { |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1089 | mark_sweep.Sweep(gc_type == kGcTypePartial, false); |
| 1090 | timings.AddSplit("Sweep"); |
| 1091 | mark_sweep.SweepLargeObjects(false); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 1092 | timings.AddSplit("SweepLargeObjects"); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1093 | } else { |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1094 | mark_sweep.SweepArray(timings, live_stack_.get(), false); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 1095 | timings.AddSplit("SweepArray"); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1096 | } |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1097 | live_stack_->Reset(); |
| 1098 | |
| 1099 | // Unbind the live and mark bitmaps. |
| 1100 | mark_sweep.UnBindBitmaps(); |
| 1101 | |
| 1102 | const bool swap = true; |
| 1103 | if (swap) { |
| 1104 | if (gc_type == kGcTypeSticky) { |
Ian Rogers | f0bbeab | 2012-10-10 18:26:27 -0700 | [diff] [blame] | 1105 | SwapLargeObjects(); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1106 | } else { |
Ian Rogers | f0bbeab | 2012-10-10 18:26:27 -0700 | [diff] [blame] | 1107 | SwapBitmaps(gc_type); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1108 | } |
| 1109 | } |
Elliott Hughes | adb460d | 2011-10-05 17:02:34 -0700 | [diff] [blame] | 1110 | |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1111 | if (verify_system_weaks_) { |
| 1112 | mark_sweep.VerifySystemWeaks(); |
| 1113 | timings.AddSplit("VerifySystemWeaks"); |
| 1114 | } |
| 1115 | |
Elliott Hughes | adb460d | 2011-10-05 17:02:34 -0700 | [diff] [blame] | 1116 | cleared_references = mark_sweep.GetClearedReferences(); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1117 | bytes_freed = mark_sweep.GetFreedBytes(); |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 1118 | total_bytes_freed_ += bytes_freed; |
| 1119 | total_objects_freed_ += mark_sweep.GetFreedObjects(); |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 1120 | } |
| 1121 | |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1122 | if (verify_post_gc_heap_) { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1123 | WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1124 | if (!VerifyHeapReferences()) { |
| 1125 | LOG(FATAL) << "Post " + gc_type_str.str() + "Gc verification failed"; |
| 1126 | } |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1127 | timings.AddSplit("VerifyHeapReferencesPostGC"); |
| 1128 | } |
| 1129 | |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 1130 | GrowForUtilization(); |
Elliott Hughes | 307f75d | 2011-10-12 18:04:40 -0700 | [diff] [blame] | 1131 | timings.AddSplit("GrowForUtilization"); |
Mathieu Chartier | b43b7d4 | 2012-06-19 13:15:09 -0700 | [diff] [blame] | 1132 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1133 | thread_list->ResumeAll(); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1134 | timings.AddSplit("ResumeAll"); |
Elliott Hughes | adb460d | 2011-10-05 17:02:34 -0700 | [diff] [blame] | 1135 | |
| 1136 | EnqueueClearedReferences(&cleared_references); |
Elliott Hughes | 8cf5bc0 | 2012-02-02 16:32:16 -0800 | [diff] [blame] | 1137 | RequestHeapTrim(); |
Mathieu Chartier | 662618f | 2012-06-06 12:01:47 -0700 | [diff] [blame] | 1138 | timings.AddSplit("Finish"); |
Elliott Hughes | 83df2ac | 2011-10-11 16:37:54 -0700 | [diff] [blame] | 1139 | |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1140 | // If the GC was slow, then print timings in the log. |
| 1141 | uint64_t duration = (NanoTime() - start_time) / 1000 * 1000; |
Mathieu Chartier | 6f1c949 | 2012-10-15 12:08:41 -0700 | [diff] [blame] | 1142 | total_paused_time_ += duration; |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1143 | if (duration > MsToNs(50)) { |
Mathieu Chartier | 637e348 | 2012-08-17 10:41:32 -0700 | [diff] [blame] | 1144 | const size_t percent_free = GetPercentFree(); |
Mathieu Chartier | 1cd9c5c | 2012-08-23 10:52:44 -0700 | [diff] [blame] | 1145 | const size_t current_heap_size = GetUsedMemorySize(); |
Mathieu Chartier | 637e348 | 2012-08-17 10:41:32 -0700 | [diff] [blame] | 1146 | const size_t total_memory = GetTotalMemory(); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1147 | LOG(INFO) << gc_cause << " " << gc_type_str.str() |
Mathieu Chartier | 637e348 | 2012-08-17 10:41:32 -0700 | [diff] [blame] | 1148 | << "GC freed " << PrettySize(bytes_freed) << ", " << percent_free << "% free, " |
Mathieu Chartier | 1cd9c5c | 2012-08-23 10:52:44 -0700 | [diff] [blame] | 1149 | << PrettySize(current_heap_size) << "/" << PrettySize(total_memory) << ", " |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1150 | << "paused " << PrettyDuration(duration); |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1151 | if (VLOG_IS_ON(heap)) { |
| 1152 | timings.Dump(); |
| 1153 | } |
Brian Carlstrom | 6b4ef02 | 2011-10-23 14:59:04 -0700 | [diff] [blame] | 1154 | } |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1155 | |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1156 | CumulativeLogger* logger = cumulative_timings_.Get(gc_type); |
| 1157 | logger->Start(); |
| 1158 | logger->AddLogger(timings); |
| 1159 | logger->End(); // Next iteration. |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1160 | } |
Mathieu Chartier | a639903 | 2012-06-11 18:49:50 -0700 | [diff] [blame] | 1161 | |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1162 | void Heap::UpdateAndMarkModUnion(MarkSweep* mark_sweep, TimingLogger& timings, GcType gc_type) { |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1163 | if (gc_type == kGcTypeSticky) { |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1164 | // Don't need to do anything for mod union table in this case since we are only scanning dirty |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1165 | // cards. |
| 1166 | return; |
| 1167 | } |
| 1168 | |
| 1169 | // Update zygote mod union table. |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1170 | if (gc_type == kGcTypePartial) { |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1171 | zygote_mod_union_table_->Update(); |
| 1172 | timings.AddSplit("UpdateZygoteModUnionTable"); |
| 1173 | |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1174 | zygote_mod_union_table_->MarkReferences(mark_sweep); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1175 | timings.AddSplit("ZygoteMarkReferences"); |
| 1176 | } |
| 1177 | |
| 1178 | // Processes the cards we cleared earlier and adds their objects into the mod-union table. |
| 1179 | mod_union_table_->Update(); |
| 1180 | timings.AddSplit("UpdateModUnionTable"); |
| 1181 | |
| 1182 | // Scans all objects in the mod-union table. |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1183 | mod_union_table_->MarkReferences(mark_sweep); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1184 | timings.AddSplit("MarkImageToAllocSpaceReferences"); |
| 1185 | } |
| 1186 | |
| 1187 | void Heap::RootMatchesObjectVisitor(const Object* root, void* arg) { |
| 1188 | Object* obj = reinterpret_cast<Object*>(arg); |
| 1189 | if (root == obj) { |
| 1190 | LOG(INFO) << "Object " << obj << " is a root"; |
| 1191 | } |
| 1192 | } |
| 1193 | |
| 1194 | class ScanVisitor { |
| 1195 | public: |
| 1196 | void operator ()(const Object* obj) const { |
| 1197 | LOG(INFO) << "Would have rescanned object " << obj; |
| 1198 | } |
| 1199 | }; |
| 1200 | |
| 1201 | class VerifyReferenceVisitor { |
| 1202 | public: |
| 1203 | VerifyReferenceVisitor(Heap* heap, bool* failed) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 1204 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, |
| 1205 | Locks::heap_bitmap_lock_) |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1206 | : heap_(heap), |
| 1207 | failed_(failed) { |
| 1208 | } |
| 1209 | |
| 1210 | // TODO: Fix lock analysis to not use NO_THREAD_SAFETY_ANALYSIS, requires support for smarter |
| 1211 | // analysis. |
| 1212 | void operator ()(const Object* obj, const Object* ref, const MemberOffset& /* offset */, |
| 1213 | bool /* is_static */) const NO_THREAD_SAFETY_ANALYSIS { |
| 1214 | // Verify that the reference is live. |
| 1215 | if (ref != NULL && !IsLive(ref)) { |
| 1216 | CardTable* card_table = heap_->GetCardTable(); |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 1217 | ObjectStack* alloc_stack = heap_->allocation_stack_.get(); |
| 1218 | ObjectStack* live_stack = heap_->live_stack_.get(); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1219 | |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1220 | byte* card_addr = card_table->CardFromAddr(obj); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1221 | LOG(ERROR) << "Object " << obj << " references dead object " << ref << "\n" |
| 1222 | << "IsDirty = " << (*card_addr == CardTable::kCardDirty) << "\n" |
| 1223 | << "Obj type " << PrettyTypeOf(obj) << "\n" |
| 1224 | << "Ref type " << PrettyTypeOf(ref); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1225 | card_table->CheckAddrIsInCardTable(reinterpret_cast<const byte*>(obj)); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1226 | void* cover_begin = card_table->AddrFromCard(card_addr); |
| 1227 | void* cover_end = reinterpret_cast<void*>(reinterpret_cast<size_t>(cover_begin) + |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1228 | CardTable::kCardSize); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1229 | LOG(ERROR) << "Card " << reinterpret_cast<void*>(card_addr) << " covers " << cover_begin |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1230 | << "-" << cover_end; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1231 | SpaceBitmap* bitmap = heap_->GetLiveBitmap()->GetSpaceBitmap(obj); |
| 1232 | |
| 1233 | // Print out how the object is live. |
| 1234 | if (bitmap->Test(obj)) { |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1235 | LOG(ERROR) << "Object " << obj << " found in live bitmap"; |
| 1236 | } |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1237 | if (std::binary_search(alloc_stack->Begin(), alloc_stack->End(), obj)) { |
| 1238 | LOG(ERROR) << "Object " << obj << " found in allocation stack"; |
| 1239 | } |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1240 | if (std::binary_search(live_stack->Begin(), live_stack->End(), obj)) { |
| 1241 | LOG(ERROR) << "Object " << obj << " found in live stack"; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1242 | } |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1243 | if (std::binary_search(live_stack->Begin(), live_stack->End(), ref)) { |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1244 | LOG(ERROR) << "Reference " << ref << " found in live stack!"; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1245 | } |
| 1246 | |
| 1247 | // Attempt to see if the card table missed the reference. |
| 1248 | ScanVisitor scan_visitor; |
| 1249 | byte* byte_cover_begin = reinterpret_cast<byte*>(card_table->AddrFromCard(card_addr)); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1250 | card_table->Scan(bitmap, byte_cover_begin, byte_cover_begin + CardTable::kCardSize, |
| 1251 | scan_visitor, IdentityFunctor()); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1252 | |
| 1253 | // Try and see if a mark sweep collector scans the reference. |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 1254 | ObjectStack* mark_stack = heap_->mark_stack_.get(); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1255 | MarkSweep ms(mark_stack); |
| 1256 | ms.Init(); |
| 1257 | mark_stack->Reset(); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1258 | ms.DisableFinger(); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1259 | |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1260 | // All the references should end up in the mark stack. |
| 1261 | ms.ScanRoot(obj); |
| 1262 | if (std::find(mark_stack->Begin(), mark_stack->End(), ref)) { |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1263 | LOG(ERROR) << "Ref found in the mark_stack when rescanning the object!"; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1264 | } else { |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1265 | LOG(ERROR) << "Dumping mark stack contents"; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1266 | for (Object** it = mark_stack->Begin(); it != mark_stack->End(); ++it) { |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1267 | LOG(ERROR) << *it; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1268 | } |
| 1269 | } |
| 1270 | mark_stack->Reset(); |
| 1271 | |
| 1272 | // Search to see if any of the roots reference our object. |
| 1273 | void* arg = const_cast<void*>(reinterpret_cast<const void*>(obj)); |
| 1274 | Runtime::Current()->VisitRoots(&Heap::RootMatchesObjectVisitor, arg); |
| 1275 | *failed_ = true; |
| 1276 | } |
| 1277 | } |
| 1278 | |
| 1279 | bool IsLive(const Object* obj) const NO_THREAD_SAFETY_ANALYSIS { |
| 1280 | SpaceBitmap* bitmap = heap_->GetLiveBitmap()->GetSpaceBitmap(obj); |
| 1281 | if (bitmap != NULL) { |
| 1282 | if (bitmap->Test(obj)) { |
| 1283 | return true; |
| 1284 | } |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1285 | } else if (heap_->GetLargeObjectsSpace()->Contains(obj)) { |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 1286 | return true; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1287 | } else { |
| 1288 | heap_->DumpSpaces(); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1289 | LOG(ERROR) << "Object " << obj << " not found in any spaces"; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1290 | } |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 1291 | ObjectStack* alloc_stack = heap_->allocation_stack_.get(); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1292 | // At this point we need to search the allocation since things in the live stack may get swept. |
| 1293 | if (std::binary_search(alloc_stack->Begin(), alloc_stack->End(), const_cast<Object*>(obj))) { |
| 1294 | return true; |
| 1295 | } |
| 1296 | // Not either in the live bitmap or allocation stack, so the object must be dead. |
| 1297 | return false; |
| 1298 | } |
| 1299 | |
| 1300 | private: |
| 1301 | Heap* heap_; |
| 1302 | bool* failed_; |
| 1303 | }; |
| 1304 | |
| 1305 | class VerifyObjectVisitor { |
| 1306 | public: |
| 1307 | VerifyObjectVisitor(Heap* heap) |
| 1308 | : heap_(heap), |
| 1309 | failed_(false) { |
| 1310 | |
| 1311 | } |
| 1312 | |
| 1313 | void operator ()(const Object* obj) const |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 1314 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, Locks::heap_bitmap_lock_) { |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1315 | VerifyReferenceVisitor visitor(heap_, const_cast<bool*>(&failed_)); |
| 1316 | MarkSweep::VisitObjectReferences(obj, visitor); |
| 1317 | } |
| 1318 | |
| 1319 | bool Failed() const { |
| 1320 | return failed_; |
| 1321 | } |
| 1322 | |
| 1323 | private: |
| 1324 | Heap* heap_; |
| 1325 | bool failed_; |
| 1326 | }; |
| 1327 | |
| 1328 | // Must do this with mutators suspended since we are directly accessing the allocation stacks. |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1329 | bool Heap::VerifyHeapReferences() { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1330 | Locks::mutator_lock_->AssertExclusiveHeld(Thread::Current()); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1331 | // Lets sort our allocation stacks so that we can efficiently binary search them. |
| 1332 | std::sort(allocation_stack_->Begin(), allocation_stack_->End()); |
| 1333 | std::sort(live_stack_->Begin(), live_stack_->End()); |
| 1334 | // Perform the verification. |
| 1335 | VerifyObjectVisitor visitor(this); |
| 1336 | GetLiveBitmap()->Visit(visitor); |
| 1337 | // We don't want to verify the objects in the allocation stack since they themselves may be |
| 1338 | // pointing to dead objects if they are not reachable. |
| 1339 | if (visitor.Failed()) { |
| 1340 | DumpSpaces(); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1341 | return false; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1342 | } |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1343 | return true; |
| 1344 | } |
| 1345 | |
| 1346 | class VerifyReferenceCardVisitor { |
| 1347 | public: |
| 1348 | VerifyReferenceCardVisitor(Heap* heap, bool* failed) |
| 1349 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, |
| 1350 | Locks::heap_bitmap_lock_) |
| 1351 | : heap_(heap), |
| 1352 | failed_(failed) { |
| 1353 | } |
| 1354 | |
| 1355 | // TODO: Fix lock analysis to not use NO_THREAD_SAFETY_ANALYSIS, requires support for smarter |
| 1356 | // analysis. |
| 1357 | void operator ()(const Object* obj, const Object* ref, const MemberOffset& offset, |
| 1358 | bool is_static) const NO_THREAD_SAFETY_ANALYSIS { |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1359 | if (ref != NULL && !obj->GetClass()->IsPrimitiveArray()) { |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1360 | CardTable* card_table = heap_->GetCardTable(); |
| 1361 | // If the object is not dirty and it is referencing something in the live stack other than |
| 1362 | // class, then it must be on a dirty card. |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1363 | if (!card_table->AddrIsInCardTable(obj)) { |
| 1364 | LOG(ERROR) << "Object " << obj << " is not in the address range of the card table"; |
| 1365 | *failed_ = true; |
| 1366 | } else if (!card_table->IsDirty(obj)) { |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 1367 | ObjectStack* live_stack = heap_->live_stack_.get(); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1368 | if (std::binary_search(live_stack->Begin(), live_stack->End(), ref) && !ref->IsClass()) { |
| 1369 | if (std::binary_search(live_stack->Begin(), live_stack->End(), obj)) { |
| 1370 | LOG(ERROR) << "Object " << obj << " found in live stack"; |
| 1371 | } |
| 1372 | if (heap_->GetLiveBitmap()->Test(obj)) { |
| 1373 | LOG(ERROR) << "Object " << obj << " found in live bitmap"; |
| 1374 | } |
| 1375 | LOG(ERROR) << "Object " << obj << " " << PrettyTypeOf(obj) |
| 1376 | << " references " << ref << " " << PrettyTypeOf(ref) << " in live stack"; |
| 1377 | |
| 1378 | // Print which field of the object is dead. |
| 1379 | if (!obj->IsObjectArray()) { |
| 1380 | const Class* klass = is_static ? obj->AsClass() : obj->GetClass(); |
| 1381 | CHECK(klass != NULL); |
| 1382 | const ObjectArray<Field>* fields = is_static ? klass->GetSFields() : klass->GetIFields(); |
| 1383 | CHECK(fields != NULL); |
| 1384 | for (int32_t i = 0; i < fields->GetLength(); ++i) { |
| 1385 | const Field* cur = fields->Get(i); |
| 1386 | if (cur->GetOffset().Int32Value() == offset.Int32Value()) { |
| 1387 | LOG(ERROR) << (is_static ? "Static " : "") << "field in the live stack is " |
| 1388 | << PrettyField(cur); |
| 1389 | break; |
| 1390 | } |
| 1391 | } |
| 1392 | } else { |
| 1393 | const ObjectArray<Object>* object_array = obj->AsObjectArray<Object>(); |
| 1394 | for (int32_t i = 0; i < object_array->GetLength(); ++i) { |
| 1395 | if (object_array->Get(i) == ref) { |
| 1396 | LOG(ERROR) << (is_static ? "Static " : "") << "obj[" << i << "] = ref"; |
| 1397 | } |
| 1398 | } |
| 1399 | } |
| 1400 | |
| 1401 | *failed_ = true; |
| 1402 | } |
| 1403 | } |
| 1404 | } |
| 1405 | } |
| 1406 | |
| 1407 | private: |
| 1408 | Heap* heap_; |
| 1409 | bool* failed_; |
| 1410 | }; |
| 1411 | |
| 1412 | class VerifyLiveStackReferences { |
| 1413 | public: |
| 1414 | VerifyLiveStackReferences(Heap* heap) |
| 1415 | : heap_(heap), |
| 1416 | failed_(false) { |
| 1417 | |
| 1418 | } |
| 1419 | |
| 1420 | void operator ()(const Object* obj) const |
| 1421 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, Locks::heap_bitmap_lock_) { |
| 1422 | VerifyReferenceCardVisitor visitor(heap_, const_cast<bool*>(&failed_)); |
| 1423 | MarkSweep::VisitObjectReferences(obj, visitor); |
| 1424 | } |
| 1425 | |
| 1426 | bool Failed() const { |
| 1427 | return failed_; |
| 1428 | } |
| 1429 | |
| 1430 | private: |
| 1431 | Heap* heap_; |
| 1432 | bool failed_; |
| 1433 | }; |
| 1434 | |
| 1435 | bool Heap::VerifyMissingCardMarks() { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1436 | Locks::mutator_lock_->AssertExclusiveHeld(Thread::Current()); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1437 | |
| 1438 | VerifyLiveStackReferences visitor(this); |
| 1439 | GetLiveBitmap()->Visit(visitor); |
| 1440 | |
| 1441 | // We can verify objects in the live stack since none of these should reference dead objects. |
| 1442 | for (Object** it = live_stack_->Begin(); it != live_stack_->End(); ++it) { |
| 1443 | visitor(*it); |
| 1444 | } |
| 1445 | |
| 1446 | if (visitor.Failed()) { |
| 1447 | DumpSpaces(); |
| 1448 | return false; |
| 1449 | } |
| 1450 | return true; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1451 | } |
| 1452 | |
Ian Rogers | f0bbeab | 2012-10-10 18:26:27 -0700 | [diff] [blame] | 1453 | void Heap::SwapBitmaps(GcType gc_type) { |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1454 | // Swap the live and mark bitmaps for each alloc space. This is needed since sweep re-swaps |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1455 | // these bitmaps. The bitmap swapping is an optimization so that we do not need to clear the live |
| 1456 | // bits of dead objects in the live bitmap. |
Ian Rogers | f0bbeab | 2012-10-10 18:26:27 -0700 | [diff] [blame] | 1457 | for (Spaces::iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
| 1458 | ContinuousSpace* space = *it; |
| 1459 | // We never allocate into zygote spaces. |
| 1460 | if (space->GetGcRetentionPolicy() == kGcRetentionPolicyAlwaysCollect || |
| 1461 | (gc_type == kGcTypeFull && |
| 1462 | space->GetGcRetentionPolicy() == kGcRetentionPolicyFullCollect)) { |
Mathieu Chartier | 128c52c | 2012-10-16 14:12:41 -0700 | [diff] [blame] | 1463 | SpaceBitmap* live_bitmap = space->GetLiveBitmap(); |
| 1464 | SpaceBitmap* mark_bitmap = space->GetMarkBitmap(); |
| 1465 | if (live_bitmap != mark_bitmap) { |
| 1466 | live_bitmap_->ReplaceBitmap(live_bitmap, mark_bitmap); |
| 1467 | mark_bitmap_->ReplaceBitmap(mark_bitmap, live_bitmap); |
| 1468 | space->AsAllocSpace()->SwapBitmaps(); |
| 1469 | } |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1470 | } |
| 1471 | } |
Ian Rogers | f0bbeab | 2012-10-10 18:26:27 -0700 | [diff] [blame] | 1472 | SwapLargeObjects(); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1473 | } |
| 1474 | |
Ian Rogers | f0bbeab | 2012-10-10 18:26:27 -0700 | [diff] [blame] | 1475 | void Heap::SwapLargeObjects() { |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 1476 | large_object_space_->SwapBitmaps(); |
| 1477 | live_bitmap_->SetLargeObjects(large_object_space_->GetLiveObjects()); |
| 1478 | mark_bitmap_->SetLargeObjects(large_object_space_->GetMarkObjects()); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1479 | } |
| 1480 | |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1481 | void Heap::SwapStacks() { |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 1482 | ObjectStack* temp = allocation_stack_.release(); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1483 | allocation_stack_.reset(live_stack_.release()); |
| 1484 | live_stack_.reset(temp); |
| 1485 | |
| 1486 | // Sort the live stack so that we can quickly binary search it later. |
| 1487 | if (VERIFY_OBJECT_ENABLED) { |
| 1488 | std::sort(live_stack_->Begin(), live_stack_->End()); |
| 1489 | } |
| 1490 | } |
| 1491 | |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1492 | void Heap::ClearCards(TimingLogger& timings) { |
| 1493 | // Clear image space cards and keep track of cards we cleared in the mod-union table. |
| 1494 | for (Spaces::iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
| 1495 | ContinuousSpace* space = *it; |
| 1496 | if (space->IsImageSpace()) { |
| 1497 | mod_union_table_->ClearCards(*it); |
| 1498 | timings.AddSplit("ModUnionClearCards"); |
| 1499 | } else if (space->GetGcRetentionPolicy() == kGcRetentionPolicyFullCollect) { |
| 1500 | zygote_mod_union_table_->ClearCards(space); |
| 1501 | timings.AddSplit("ZygoteModUnionClearCards"); |
| 1502 | } else { |
| 1503 | card_table_->ClearSpaceCards(space); |
| 1504 | timings.AddSplit("ClearCards"); |
| 1505 | } |
| 1506 | } |
| 1507 | } |
| 1508 | |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 1509 | void Heap::CollectGarbageConcurrentMarkSweepPlan(Thread* self, GcType gc_type, GcCause gc_cause, |
| 1510 | bool clear_soft_references) { |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1511 | TimingLogger timings("ConcurrentCollectGarbageInternal", true); |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1512 | uint64_t gc_begin = NanoTime(), root_begin = 0, root_end = 0, dirty_begin = 0, dirty_end = 0; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1513 | std::stringstream gc_type_str; |
| 1514 | gc_type_str << gc_type << " "; |
Mathieu Chartier | a639903 | 2012-06-11 18:49:50 -0700 | [diff] [blame] | 1515 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1516 | ThreadList* thread_list = Runtime::Current()->GetThreadList(); |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1517 | std::vector<byte*> dirty_cards; |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1518 | size_t bytes_freed = 0; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1519 | Object* cleared_references = NULL; |
| 1520 | { |
| 1521 | MarkSweep mark_sweep(mark_stack_.get()); |
| 1522 | timings.AddSplit("ctor"); |
| 1523 | |
| 1524 | mark_sweep.Init(); |
| 1525 | timings.AddSplit("Init"); |
| 1526 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1527 | { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1528 | WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1529 | |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1530 | if (gc_type == kGcTypePartial) { |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1531 | // Copy the mark bits over from the live bits, do this as early as possible or else we can |
| 1532 | // accidentally un-mark roots. |
| 1533 | // Needed for scanning dirty objects. |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1534 | for (Spaces::iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1535 | if ((*it)->GetGcRetentionPolicy() == kGcRetentionPolicyFullCollect) { |
| 1536 | mark_sweep.BindLiveToMarkBitmap(*it); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1537 | } |
| 1538 | } |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1539 | timings.AddSplit("BindLiveToMark"); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 1540 | mark_sweep.SetImmuneRange(reinterpret_cast<Object*>(spaces_.front()->Begin()), |
| 1541 | reinterpret_cast<Object*>(alloc_space_->Begin())); |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1542 | } else if (gc_type == kGcTypeSticky) { |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1543 | for (Spaces::iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1544 | if ((*it)->GetGcRetentionPolicy() != kGcRetentionPolicyNeverCollect) { |
| 1545 | mark_sweep.BindLiveToMarkBitmap(*it); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1546 | } |
| 1547 | } |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1548 | timings.AddSplit("BindLiveToMark"); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 1549 | large_object_space_->CopyLiveToMarked(); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1550 | timings.AddSplit("CopyLiveToMarked"); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 1551 | mark_sweep.SetImmuneRange(reinterpret_cast<Object*>(spaces_.front()->Begin()), |
| 1552 | reinterpret_cast<Object*>(alloc_space_->Begin())); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1553 | } |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1554 | mark_sweep.FindDefaultMarkBitmap(); |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1555 | } |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1556 | |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1557 | mark_sweep.MarkRootsCheckpoint(); |
| 1558 | timings.AddSplit("MarkRootsCheckpoint"); |
| 1559 | |
| 1560 | { |
| 1561 | root_begin = NanoTime(); |
| 1562 | |
| 1563 | // Suspend all threads are get exclusive access to the heap. |
| 1564 | thread_list->SuspendAll(); |
| 1565 | timings.AddSplit("SuspendAll"); |
| 1566 | Locks::mutator_lock_->AssertExclusiveHeld(self); |
| 1567 | |
| 1568 | if (verify_pre_gc_heap_) { |
| 1569 | WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); |
| 1570 | if (!VerifyHeapReferences()) { |
| 1571 | LOG(FATAL) << "Pre " << gc_type_str.str() << "Gc verification failed"; |
| 1572 | } |
| 1573 | timings.AddSplit("VerifyHeapReferencesPreGC"); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1574 | } |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1575 | |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1576 | // Swap the stacks, this is safe since all the mutators are suspended at this point. |
| 1577 | SwapStacks(); |
| 1578 | |
| 1579 | // Check that all objects which reference things in the live stack are on dirty cards. |
| 1580 | if (verify_missing_card_marks_) { |
| 1581 | ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_); |
| 1582 | // Sort the live stack so that we can quickly binary search it later. |
| 1583 | std::sort(live_stack_->Begin(), live_stack_->End()); |
| 1584 | if (!VerifyMissingCardMarks()) { |
| 1585 | LOG(FATAL) << "Pre GC verification of missing card marks failed"; |
| 1586 | } |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1587 | } |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1588 | |
| 1589 | // We will need to know which cards were dirty for doing concurrent processing of dirty cards. |
| 1590 | // TODO: Investigate using a mark stack instead of a vector. |
| 1591 | if (gc_type == kGcTypeSticky) { |
| 1592 | dirty_cards.reserve(4 * KB); |
| 1593 | for (Spaces::iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
| 1594 | card_table_->GetDirtyCards(*it, dirty_cards); |
| 1595 | } |
| 1596 | timings.AddSplit("GetDirtyCards"); |
| 1597 | } |
| 1598 | |
| 1599 | // Clear image space cards and keep track of cards we cleared in the mod-union table. |
| 1600 | ClearCards(timings); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1601 | } |
| 1602 | |
| 1603 | // Roots are marked on the bitmap and the mark_stack is empty. |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 1604 | DCHECK(mark_stack_->IsEmpty()); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1605 | |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1606 | if (verify_mod_union_table_) { |
| 1607 | ReaderMutexLock reader_lock(self, *Locks::heap_bitmap_lock_); |
| 1608 | zygote_mod_union_table_->Update(); |
| 1609 | zygote_mod_union_table_->Verify(); |
| 1610 | mod_union_table_->Update(); |
| 1611 | mod_union_table_->Verify(); |
| 1612 | } |
| 1613 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1614 | // Allow mutators to go again, acquire share on mutator_lock_ to continue. |
| 1615 | thread_list->ResumeAll(); |
| 1616 | { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1617 | ReaderMutexLock reader_lock(self, *Locks::mutator_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1618 | root_end = NanoTime(); |
| 1619 | timings.AddSplit("RootEnd"); |
| 1620 | |
Mathieu Chartier | 9ebae1f | 2012-10-15 17:38:16 -0700 | [diff] [blame] | 1621 | // Mark the roots which we can do concurrently. |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1622 | WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); |
Mathieu Chartier | 9ebae1f | 2012-10-15 17:38:16 -0700 | [diff] [blame] | 1623 | mark_sweep.MarkConcurrentRoots(); |
| 1624 | timings.AddSplit("MarkConcurrentRoots"); |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1625 | mark_sweep.MarkNonThreadRoots(); |
| 1626 | timings.AddSplit("MarkNonThreadRoots"); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1627 | |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1628 | if (gc_type != kGcTypeSticky) { |
| 1629 | // Mark everything allocated since the last as GC live so that we can sweep concurrently, |
| 1630 | // knowing that new allocations won't be marked as live. |
| 1631 | MarkAllocStack(alloc_space_->GetLiveBitmap(), large_object_space_->GetLiveObjects(), |
| 1632 | live_stack_.get()); |
| 1633 | timings.AddSplit("MarkStackAsLive"); |
| 1634 | } |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1635 | |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1636 | UpdateAndMarkModUnion(&mark_sweep, timings, gc_type); |
| 1637 | |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1638 | if (gc_type != kGcTypeSticky) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1639 | // Recursively mark all the non-image bits set in the mark bitmap. |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1640 | mark_sweep.RecursiveMark(gc_type == kGcTypePartial, timings); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1641 | } else { |
| 1642 | mark_sweep.RecursiveMarkCards(card_table_.get(), dirty_cards, timings); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1643 | } |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1644 | mark_sweep.DisableFinger(); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1645 | } |
| 1646 | // Release share on mutator_lock_ and then get exclusive access. |
| 1647 | dirty_begin = NanoTime(); |
| 1648 | thread_list->SuspendAll(); |
| 1649 | timings.AddSplit("ReSuspend"); |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1650 | Locks::mutator_lock_->AssertExclusiveHeld(self); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1651 | |
| 1652 | { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1653 | WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1654 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1655 | // Re-mark root set. |
| 1656 | mark_sweep.ReMarkRoots(); |
| 1657 | timings.AddSplit("ReMarkRoots"); |
| 1658 | |
| 1659 | // Scan dirty objects, this is only required if we are not doing concurrent GC. |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1660 | mark_sweep.RecursiveMarkDirtyObjects(false); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1661 | timings.AddSplit("RecursiveMarkDirtyObjects"); |
| 1662 | } |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1663 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1664 | { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1665 | ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1666 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1667 | mark_sweep.ProcessReferences(clear_soft_references); |
| 1668 | timings.AddSplit("ProcessReferences"); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1669 | } |
| 1670 | |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1671 | // Only need to do this if we have the card mark verification on, and only during concurrent GC. |
| 1672 | if (verify_missing_card_marks_) { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1673 | WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1674 | mark_sweep.SweepArray(timings, allocation_stack_.get(), false); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1675 | } else { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1676 | WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1677 | // We only sweep over the live stack, and the live stack should not intersect with the |
| 1678 | // allocation stack, so it should be safe to UnMark anything in the allocation stack as live. |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1679 | UnMarkAllocStack(alloc_space_->GetMarkBitmap(), large_object_space_->GetMarkObjects(), |
| 1680 | allocation_stack_.get()); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1681 | timings.AddSplit("UnMarkAllocStack"); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1682 | #ifndef NDEBUG |
| 1683 | if (gc_type == kGcTypeSticky) { |
| 1684 | // Make sure everything in the live stack isn't something we unmarked. |
| 1685 | std::sort(allocation_stack_->Begin(), allocation_stack_->End()); |
| 1686 | for (Object** it = live_stack_->Begin(); it != live_stack_->End(); ++it) { |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 1687 | DCHECK(!std::binary_search(allocation_stack_->Begin(), allocation_stack_->End(), *it)) |
| 1688 | << "Unmarked object " << *it << " in the live stack"; |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1689 | } |
| 1690 | } else { |
| 1691 | for (Object** it = allocation_stack_->Begin(); it != allocation_stack_->End(); ++it) { |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 1692 | DCHECK(!GetLiveBitmap()->Test(*it)) << "Object " << *it << " is marked as live"; |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1693 | } |
| 1694 | } |
| 1695 | #endif |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1696 | } |
| 1697 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1698 | if (kIsDebugBuild) { |
| 1699 | // Verify that we only reach marked objects from the image space. |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1700 | ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1701 | mark_sweep.VerifyImageRoots(); |
| 1702 | timings.AddSplit("VerifyImageRoots"); |
| 1703 | } |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1704 | |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1705 | if (verify_post_gc_heap_) { |
Ian Rogers | f0bbeab | 2012-10-10 18:26:27 -0700 | [diff] [blame] | 1706 | WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); |
Mathieu Chartier | 128c52c | 2012-10-16 14:12:41 -0700 | [diff] [blame] | 1707 | // Swapping bound bitmaps does nothing. |
| 1708 | SwapBitmaps(kGcTypeFull); |
Ian Rogers | f0bbeab | 2012-10-10 18:26:27 -0700 | [diff] [blame] | 1709 | if (!VerifyHeapReferences()) { |
| 1710 | LOG(FATAL) << "Post " << gc_type_str.str() << "Gc verification failed"; |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1711 | } |
Mathieu Chartier | 128c52c | 2012-10-16 14:12:41 -0700 | [diff] [blame] | 1712 | SwapBitmaps(kGcTypeFull); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1713 | timings.AddSplit("VerifyHeapReferencesPostGC"); |
| 1714 | } |
| 1715 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1716 | thread_list->ResumeAll(); |
| 1717 | dirty_end = NanoTime(); |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1718 | Locks::mutator_lock_->AssertNotHeld(self); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1719 | |
| 1720 | { |
| 1721 | // TODO: this lock shouldn't be necessary (it's why we did the bitmap flip above). |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1722 | if (gc_type != kGcTypeSticky) { |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 1723 | WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1724 | mark_sweep.Sweep(gc_type == kGcTypePartial, false); |
| 1725 | timings.AddSplit("Sweep"); |
| 1726 | mark_sweep.SweepLargeObjects(false); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 1727 | timings.AddSplit("SweepLargeObjects"); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1728 | } else { |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 1729 | WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1730 | mark_sweep.SweepArray(timings, live_stack_.get(), false); |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 1731 | timings.AddSplit("SweepArray"); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1732 | } |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1733 | live_stack_->Reset(); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1734 | } |
| 1735 | |
| 1736 | { |
| 1737 | WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); |
| 1738 | // Unbind the live and mark bitmaps. |
| 1739 | mark_sweep.UnBindBitmaps(); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1740 | |
Ian Rogers | f0bbeab | 2012-10-10 18:26:27 -0700 | [diff] [blame] | 1741 | // Swap the live and mark bitmaps for each space which we modified space. This is an |
| 1742 | // optimization that enables us to not clear live bits inside of the sweep. |
| 1743 | const bool swap = true; |
| 1744 | if (swap) { |
| 1745 | if (gc_type == kGcTypeSticky) { |
| 1746 | SwapLargeObjects(); |
| 1747 | } else { |
| 1748 | SwapBitmaps(gc_type); |
| 1749 | } |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 1750 | } |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1751 | } |
| 1752 | |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1753 | if (verify_system_weaks_) { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1754 | ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1755 | mark_sweep.VerifySystemWeaks(); |
| 1756 | timings.AddSplit("VerifySystemWeaks"); |
| 1757 | } |
| 1758 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1759 | cleared_references = mark_sweep.GetClearedReferences(); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1760 | bytes_freed = mark_sweep.GetFreedBytes(); |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 1761 | total_bytes_freed_ += bytes_freed; |
| 1762 | total_objects_freed_ += mark_sweep.GetFreedObjects(); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1763 | } |
| 1764 | |
| 1765 | GrowForUtilization(); |
| 1766 | timings.AddSplit("GrowForUtilization"); |
| 1767 | |
| 1768 | EnqueueClearedReferences(&cleared_references); |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 1769 | timings.AddSplit("EnqueueClearedReferences"); |
| 1770 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1771 | RequestHeapTrim(); |
| 1772 | timings.AddSplit("Finish"); |
| 1773 | |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1774 | // If the GC was slow, then print timings in the log. |
| 1775 | uint64_t pause_roots = (root_end - root_begin) / 1000 * 1000; |
| 1776 | uint64_t pause_dirty = (dirty_end - dirty_begin) / 1000 * 1000; |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1777 | uint64_t duration = (NanoTime() - gc_begin) / 1000 * 1000; |
Mathieu Chartier | 6f1c949 | 2012-10-15 12:08:41 -0700 | [diff] [blame] | 1778 | total_paused_time_ += pause_roots + pause_dirty; |
Mathieu Chartier | 0051be6 | 2012-10-12 17:47:11 -0700 | [diff] [blame] | 1779 | if (pause_roots > MsToNs(5) || pause_dirty > MsToNs(5) || |
| 1780 | (gc_cause == kGcCauseForAlloc && duration > MsToNs(20))) { |
Mathieu Chartier | 637e348 | 2012-08-17 10:41:32 -0700 | [diff] [blame] | 1781 | const size_t percent_free = GetPercentFree(); |
Mathieu Chartier | 1cd9c5c | 2012-08-23 10:52:44 -0700 | [diff] [blame] | 1782 | const size_t current_heap_size = GetUsedMemorySize(); |
Mathieu Chartier | 637e348 | 2012-08-17 10:41:32 -0700 | [diff] [blame] | 1783 | const size_t total_memory = GetTotalMemory(); |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 1784 | LOG(INFO) << gc_cause << " " << gc_type_str.str() |
Mathieu Chartier | 637e348 | 2012-08-17 10:41:32 -0700 | [diff] [blame] | 1785 | << "Concurrent GC freed " << PrettySize(bytes_freed) << ", " << percent_free |
Mathieu Chartier | 1cd9c5c | 2012-08-23 10:52:44 -0700 | [diff] [blame] | 1786 | << "% free, " << PrettySize(current_heap_size) << "/" |
Mathieu Chartier | 637e348 | 2012-08-17 10:41:32 -0700 | [diff] [blame] | 1787 | << PrettySize(total_memory) << ", " << "paused " << PrettyDuration(pause_roots) |
| 1788 | << "+" << PrettyDuration(pause_dirty) << " total " << PrettyDuration(duration); |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1789 | if (VLOG_IS_ON(heap)) { |
| 1790 | timings.Dump(); |
| 1791 | } |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1792 | } |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1793 | |
Mathieu Chartier | 0325e62 | 2012-09-05 14:22:51 -0700 | [diff] [blame] | 1794 | CumulativeLogger* logger = cumulative_timings_.Get(gc_type); |
| 1795 | logger->Start(); |
| 1796 | logger->AddLogger(timings); |
| 1797 | logger->End(); // Next iteration. |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 1798 | } |
| 1799 | |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1800 | GcType Heap::WaitForConcurrentGcToComplete(Thread* self) { |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 1801 | GcType last_gc_type = kGcTypeNone; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1802 | if (concurrent_gc_) { |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 1803 | bool do_wait; |
| 1804 | uint64_t wait_start = NanoTime(); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1805 | { |
| 1806 | // Check if GC is running holding gc_complete_lock_. |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1807 | MutexLock mu(self, *gc_complete_lock_); |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 1808 | do_wait = is_gc_running_; |
Mathieu Chartier | a639903 | 2012-06-11 18:49:50 -0700 | [diff] [blame] | 1809 | } |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1810 | if (do_wait) { |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 1811 | uint64_t wait_time; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1812 | // We must wait, change thread state then sleep on gc_complete_cond_; |
| 1813 | ScopedThreadStateChange tsc(Thread::Current(), kWaitingForGcToComplete); |
| 1814 | { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1815 | MutexLock mu(self, *gc_complete_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1816 | while (is_gc_running_) { |
Ian Rogers | c604d73 | 2012-10-14 16:09:54 -0700 | [diff] [blame] | 1817 | gc_complete_cond_->Wait(self); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1818 | } |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 1819 | last_gc_type = last_gc_type_; |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 1820 | wait_time = NanoTime() - wait_start;; |
| 1821 | total_wait_time_ += wait_time; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1822 | } |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1823 | if (wait_time > MsToNs(5)) { |
| 1824 | LOG(INFO) << "WaitForConcurrentGcToComplete blocked for " << PrettyDuration(wait_time); |
| 1825 | } |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1826 | } |
Mathieu Chartier | 7664f5c | 2012-06-08 18:15:32 -0700 | [diff] [blame] | 1827 | } |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 1828 | return last_gc_type; |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 1829 | } |
| 1830 | |
Elliott Hughes | c967f78 | 2012-04-16 10:23:15 -0700 | [diff] [blame] | 1831 | void Heap::DumpForSigQuit(std::ostream& os) { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 1832 | os << "Heap: " << GetPercentFree() << "% free, " << PrettySize(GetUsedMemorySize()) << "/" |
| 1833 | << PrettySize(GetTotalMemory()) << "; " << GetObjectsAllocated() << " objects\n"; |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 1834 | DumpGcPerformanceInfo(); |
Elliott Hughes | c967f78 | 2012-04-16 10:23:15 -0700 | [diff] [blame] | 1835 | } |
| 1836 | |
| 1837 | size_t Heap::GetPercentFree() { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 1838 | return static_cast<size_t>(100.0f * static_cast<float>(GetFreeMemory()) / GetTotalMemory()); |
Elliott Hughes | c967f78 | 2012-04-16 10:23:15 -0700 | [diff] [blame] | 1839 | } |
| 1840 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1841 | void Heap::SetIdealFootprint(size_t max_allowed_footprint) { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 1842 | if (max_allowed_footprint > GetMaxMemory()) { |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1843 | VLOG(gc) << "Clamp target GC heap from " << PrettySize(max_allowed_footprint) << " to " |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 1844 | << PrettySize(GetMaxMemory()); |
| 1845 | max_allowed_footprint = GetMaxMemory(); |
| 1846 | } |
Mathieu Chartier | 1c23e1e | 2012-10-12 14:14:11 -0700 | [diff] [blame] | 1847 | max_allowed_footprint_ = max_allowed_footprint; |
Shih-wei Liao | 8c2f641 | 2011-10-03 22:58:14 -0700 | [diff] [blame] | 1848 | } |
| 1849 | |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 1850 | void Heap::GrowForUtilization() { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 1851 | // We know what our utilization is at this moment. |
| 1852 | // This doesn't actually resize any memory. It just lets the heap grow more when necessary. |
| 1853 | size_t target_size = num_bytes_allocated_ / Heap::GetTargetHeapUtilization(); |
Mathieu Chartier | 0051be6 | 2012-10-12 17:47:11 -0700 | [diff] [blame] | 1854 | if (target_size > num_bytes_allocated_ + max_free_) { |
| 1855 | target_size = num_bytes_allocated_ + max_free_; |
| 1856 | } else if (target_size < num_bytes_allocated_ + min_free_) { |
| 1857 | target_size = num_bytes_allocated_ + min_free_; |
Shih-wei Liao | 8c2f641 | 2011-10-03 22:58:14 -0700 | [diff] [blame] | 1858 | } |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1859 | |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 1860 | // Calculate when to perform the next ConcurrentGC. |
| 1861 | if (GetFreeMemory() < concurrent_min_free_) { |
| 1862 | // Not enough free memory to perform concurrent GC. |
| 1863 | concurrent_start_bytes_ = std::numeric_limits<size_t>::max(); |
| 1864 | } else { |
| 1865 | // Start a concurrent Gc when we get close to the target size. |
| 1866 | concurrent_start_bytes_ = target_size - concurrent_start_size_; |
Mathieu Chartier | 7664f5c | 2012-06-08 18:15:32 -0700 | [diff] [blame] | 1867 | } |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 1868 | |
Shih-wei Liao | 8c2f641 | 2011-10-03 22:58:14 -0700 | [diff] [blame] | 1869 | SetIdealFootprint(target_size); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 1870 | } |
| 1871 | |
jeffhao | c116070 | 2011-10-27 15:48:45 -0700 | [diff] [blame] | 1872 | void Heap::ClearGrowthLimit() { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 1873 | WaitForConcurrentGcToComplete(Thread::Current()); |
jeffhao | c116070 | 2011-10-27 15:48:45 -0700 | [diff] [blame] | 1874 | alloc_space_->ClearGrowthLimit(); |
| 1875 | } |
| 1876 | |
Elliott Hughes | adb460d | 2011-10-05 17:02:34 -0700 | [diff] [blame] | 1877 | void Heap::SetReferenceOffsets(MemberOffset reference_referent_offset, |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1878 | MemberOffset reference_queue_offset, |
| 1879 | MemberOffset reference_queueNext_offset, |
| 1880 | MemberOffset reference_pendingNext_offset, |
| 1881 | MemberOffset finalizer_reference_zombie_offset) { |
Elliott Hughes | adb460d | 2011-10-05 17:02:34 -0700 | [diff] [blame] | 1882 | reference_referent_offset_ = reference_referent_offset; |
| 1883 | reference_queue_offset_ = reference_queue_offset; |
| 1884 | reference_queueNext_offset_ = reference_queueNext_offset; |
| 1885 | reference_pendingNext_offset_ = reference_pendingNext_offset; |
| 1886 | finalizer_reference_zombie_offset_ = finalizer_reference_zombie_offset; |
| 1887 | CHECK_NE(reference_referent_offset_.Uint32Value(), 0U); |
| 1888 | CHECK_NE(reference_queue_offset_.Uint32Value(), 0U); |
| 1889 | CHECK_NE(reference_queueNext_offset_.Uint32Value(), 0U); |
| 1890 | CHECK_NE(reference_pendingNext_offset_.Uint32Value(), 0U); |
| 1891 | CHECK_NE(finalizer_reference_zombie_offset_.Uint32Value(), 0U); |
| 1892 | } |
| 1893 | |
| 1894 | Object* Heap::GetReferenceReferent(Object* reference) { |
| 1895 | DCHECK(reference != NULL); |
| 1896 | DCHECK_NE(reference_referent_offset_.Uint32Value(), 0U); |
| 1897 | return reference->GetFieldObject<Object*>(reference_referent_offset_, true); |
| 1898 | } |
| 1899 | |
| 1900 | void Heap::ClearReferenceReferent(Object* reference) { |
| 1901 | DCHECK(reference != NULL); |
| 1902 | DCHECK_NE(reference_referent_offset_.Uint32Value(), 0U); |
| 1903 | reference->SetFieldObject(reference_referent_offset_, NULL, true); |
| 1904 | } |
| 1905 | |
| 1906 | // Returns true if the reference object has not yet been enqueued. |
| 1907 | bool Heap::IsEnqueuable(const Object* ref) { |
| 1908 | DCHECK(ref != NULL); |
| 1909 | const Object* queue = ref->GetFieldObject<Object*>(reference_queue_offset_, false); |
| 1910 | const Object* queue_next = ref->GetFieldObject<Object*>(reference_queueNext_offset_, false); |
| 1911 | return (queue != NULL) && (queue_next == NULL); |
| 1912 | } |
| 1913 | |
| 1914 | void Heap::EnqueueReference(Object* ref, Object** cleared_reference_list) { |
| 1915 | DCHECK(ref != NULL); |
| 1916 | CHECK(ref->GetFieldObject<Object*>(reference_queue_offset_, false) != NULL); |
| 1917 | CHECK(ref->GetFieldObject<Object*>(reference_queueNext_offset_, false) == NULL); |
| 1918 | EnqueuePendingReference(ref, cleared_reference_list); |
| 1919 | } |
| 1920 | |
| 1921 | void Heap::EnqueuePendingReference(Object* ref, Object** list) { |
| 1922 | DCHECK(ref != NULL); |
| 1923 | DCHECK(list != NULL); |
| 1924 | |
| 1925 | if (*list == NULL) { |
| 1926 | ref->SetFieldObject(reference_pendingNext_offset_, ref, false); |
| 1927 | *list = ref; |
| 1928 | } else { |
| 1929 | Object* head = (*list)->GetFieldObject<Object*>(reference_pendingNext_offset_, false); |
| 1930 | ref->SetFieldObject(reference_pendingNext_offset_, head, false); |
| 1931 | (*list)->SetFieldObject(reference_pendingNext_offset_, ref, false); |
| 1932 | } |
| 1933 | } |
| 1934 | |
| 1935 | Object* Heap::DequeuePendingReference(Object** list) { |
| 1936 | DCHECK(list != NULL); |
| 1937 | DCHECK(*list != NULL); |
| 1938 | Object* head = (*list)->GetFieldObject<Object*>(reference_pendingNext_offset_, false); |
| 1939 | Object* ref; |
| 1940 | if (*list == head) { |
| 1941 | ref = *list; |
| 1942 | *list = NULL; |
| 1943 | } else { |
| 1944 | Object* next = head->GetFieldObject<Object*>(reference_pendingNext_offset_, false); |
| 1945 | (*list)->SetFieldObject(reference_pendingNext_offset_, next, false); |
| 1946 | ref = head; |
| 1947 | } |
| 1948 | ref->SetFieldObject(reference_pendingNext_offset_, NULL, false); |
| 1949 | return ref; |
| 1950 | } |
| 1951 | |
Ian Rogers | 5d4bdc2 | 2011-11-02 22:15:43 -0700 | [diff] [blame] | 1952 | void Heap::AddFinalizerReference(Thread* self, Object* object) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1953 | ScopedObjectAccess soa(self); |
Elliott Hughes | 7740579 | 2012-03-15 15:22:12 -0700 | [diff] [blame] | 1954 | JValue args[1]; |
Elliott Hughes | f24d3ce | 2012-04-11 17:43:37 -0700 | [diff] [blame] | 1955 | args[0].SetL(object); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1956 | soa.DecodeMethod(WellKnownClasses::java_lang_ref_FinalizerReference_add)->Invoke(self, NULL, args, |
| 1957 | NULL); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1958 | } |
| 1959 | |
| 1960 | size_t Heap::GetBytesAllocated() const { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1961 | return num_bytes_allocated_; |
| 1962 | } |
| 1963 | |
| 1964 | size_t Heap::GetObjectsAllocated() const { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 1965 | size_t total = 0; |
| 1966 | // TODO: C++0x |
| 1967 | for (Spaces::const_iterator it = spaces_.begin(); it != spaces_.end(); ++it) { |
| 1968 | Space* space = *it; |
| 1969 | if (space->IsAllocSpace()) { |
| 1970 | total += space->AsAllocSpace()->GetNumObjectsAllocated(); |
| 1971 | } |
| 1972 | } |
| 1973 | return total; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1974 | } |
| 1975 | |
| 1976 | size_t Heap::GetConcurrentStartSize() const { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1977 | return concurrent_start_size_; |
| 1978 | } |
| 1979 | |
| 1980 | size_t Heap::GetConcurrentMinFree() const { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1981 | return concurrent_min_free_; |
Elliott Hughes | adb460d | 2011-10-05 17:02:34 -0700 | [diff] [blame] | 1982 | } |
| 1983 | |
| 1984 | void Heap::EnqueueClearedReferences(Object** cleared) { |
| 1985 | DCHECK(cleared != NULL); |
| 1986 | if (*cleared != NULL) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1987 | ScopedObjectAccess soa(Thread::Current()); |
Elliott Hughes | 7740579 | 2012-03-15 15:22:12 -0700 | [diff] [blame] | 1988 | JValue args[1]; |
Elliott Hughes | f24d3ce | 2012-04-11 17:43:37 -0700 | [diff] [blame] | 1989 | args[0].SetL(*cleared); |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1990 | soa.DecodeMethod(WellKnownClasses::java_lang_ref_ReferenceQueue_add)->Invoke(soa.Self(), NULL, |
| 1991 | args, NULL); |
Elliott Hughes | adb460d | 2011-10-05 17:02:34 -0700 | [diff] [blame] | 1992 | *cleared = NULL; |
| 1993 | } |
| 1994 | } |
| 1995 | |
Ian Rogers | 1f53934 | 2012-10-03 21:09:42 -0700 | [diff] [blame] | 1996 | void Heap::RequestConcurrentGC(Thread* self) { |
Mathieu Chartier | 069387a | 2012-06-18 12:01:01 -0700 | [diff] [blame] | 1997 | // Make sure that we can do a concurrent GC. |
Ian Rogers | 120f1c7 | 2012-09-28 17:17:10 -0700 | [diff] [blame] | 1998 | Runtime* runtime = Runtime::Current(); |
| 1999 | if (requesting_gc_ || runtime == NULL || !runtime->IsFinishedStarting() || |
| 2000 | !runtime->IsConcurrentGcEnabled()) { |
| 2001 | return; |
| 2002 | } |
Ian Rogers | 120f1c7 | 2012-09-28 17:17:10 -0700 | [diff] [blame] | 2003 | { |
| 2004 | MutexLock mu(self, *Locks::runtime_shutdown_lock_); |
| 2005 | if (runtime->IsShuttingDown()) { |
| 2006 | return; |
| 2007 | } |
| 2008 | } |
| 2009 | if (self->IsHandlingStackOverflow()) { |
Mathieu Chartier | 7664f5c | 2012-06-08 18:15:32 -0700 | [diff] [blame] | 2010 | return; |
| 2011 | } |
| 2012 | |
| 2013 | requesting_gc_ = true; |
Ian Rogers | 120f1c7 | 2012-09-28 17:17:10 -0700 | [diff] [blame] | 2014 | JNIEnv* env = self->GetJniEnv(); |
Mathieu Chartier | a639903 | 2012-06-11 18:49:50 -0700 | [diff] [blame] | 2015 | DCHECK(WellKnownClasses::java_lang_Daemons != NULL); |
| 2016 | DCHECK(WellKnownClasses::java_lang_Daemons_requestGC != NULL); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 2017 | env->CallStaticVoidMethod(WellKnownClasses::java_lang_Daemons, |
| 2018 | WellKnownClasses::java_lang_Daemons_requestGC); |
Mathieu Chartier | 7664f5c | 2012-06-08 18:15:32 -0700 | [diff] [blame] | 2019 | CHECK(!env->ExceptionCheck()); |
| 2020 | requesting_gc_ = false; |
| 2021 | } |
| 2022 | |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 2023 | void Heap::ConcurrentGC(Thread* self) { |
Ian Rogers | 120f1c7 | 2012-09-28 17:17:10 -0700 | [diff] [blame] | 2024 | { |
| 2025 | MutexLock mu(self, *Locks::runtime_shutdown_lock_); |
| 2026 | if (Runtime::Current()->IsShuttingDown() || !concurrent_gc_) { |
| 2027 | return; |
| 2028 | } |
Mathieu Chartier | 2542d66 | 2012-06-21 17:14:11 -0700 | [diff] [blame] | 2029 | } |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 2030 | |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 2031 | if (WaitForConcurrentGcToComplete(self) == kGcTypeNone) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 2032 | // Start a concurrent GC as one wasn't in progress |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 2033 | ScopedThreadStateChange tsc(self, kWaitingPerformingGc); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 2034 | if (alloc_space_->Size() > min_alloc_space_size_for_sticky_gc_) { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 2035 | CollectGarbageInternal(kGcTypeSticky, kGcCauseBackground, false); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 2036 | } else { |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 2037 | CollectGarbageInternal(kGcTypePartial, kGcCauseBackground, false); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 2038 | } |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 2039 | } |
Mathieu Chartier | 7664f5c | 2012-06-08 18:15:32 -0700 | [diff] [blame] | 2040 | } |
| 2041 | |
Mathieu Chartier | 3056d0c | 2012-10-19 10:49:56 -0700 | [diff] [blame] | 2042 | void Heap::Trim() { |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 2043 | alloc_space_->Trim(); |
Mathieu Chartier | 7664f5c | 2012-06-08 18:15:32 -0700 | [diff] [blame] | 2044 | } |
| 2045 | |
Elliott Hughes | 8cf5bc0 | 2012-02-02 16:32:16 -0800 | [diff] [blame] | 2046 | void Heap::RequestHeapTrim() { |
| 2047 | // We don't have a good measure of how worthwhile a trim might be. We can't use the live bitmap |
| 2048 | // because that only marks object heads, so a large array looks like lots of empty space. We |
| 2049 | // don't just call dlmalloc all the time, because the cost of an _attempted_ trim is proportional |
| 2050 | // to utilization (which is probably inversely proportional to how much benefit we can expect). |
| 2051 | // We could try mincore(2) but that's only a measure of how many pages we haven't given away, |
| 2052 | // not how much use we're making of those pages. |
Mathieu Chartier | 7664f5c | 2012-06-08 18:15:32 -0700 | [diff] [blame] | 2053 | uint64_t ms_time = NsToMs(NanoTime()); |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 2054 | float utilization = |
| 2055 | static_cast<float>(alloc_space_->GetNumBytesAllocated()) / alloc_space_->Size(); |
| 2056 | if ((utilization > 0.75f) || ((ms_time - last_trim_time_) < 2 * 1000)) { |
| 2057 | // Don't bother trimming the alloc space if it's more than 75% utilized, or if a |
| 2058 | // heap trim occurred in the last two seconds. |
| 2059 | return; |
Elliott Hughes | 8cf5bc0 | 2012-02-02 16:32:16 -0800 | [diff] [blame] | 2060 | } |
Ian Rogers | 120f1c7 | 2012-09-28 17:17:10 -0700 | [diff] [blame] | 2061 | |
| 2062 | Thread* self = Thread::Current(); |
| 2063 | { |
| 2064 | MutexLock mu(self, *Locks::runtime_shutdown_lock_); |
| 2065 | Runtime* runtime = Runtime::Current(); |
| 2066 | if (runtime == NULL || !runtime->IsFinishedStarting() || runtime->IsShuttingDown()) { |
| 2067 | // Heap trimming isn't supported without a Java runtime or Daemons (such as at dex2oat time) |
| 2068 | // Also: we do not wish to start a heap trim if the runtime is shutting down (a racy check |
| 2069 | // as we don't hold the lock while requesting the trim). |
| 2070 | return; |
| 2071 | } |
Ian Rogers | e1d490c | 2012-02-03 09:09:07 -0800 | [diff] [blame] | 2072 | } |
Mathieu Chartier | 7664f5c | 2012-06-08 18:15:32 -0700 | [diff] [blame] | 2073 | last_trim_time_ = ms_time; |
Ian Rogers | 120f1c7 | 2012-09-28 17:17:10 -0700 | [diff] [blame] | 2074 | JNIEnv* env = self->GetJniEnv(); |
Mathieu Chartier | a639903 | 2012-06-11 18:49:50 -0700 | [diff] [blame] | 2075 | DCHECK(WellKnownClasses::java_lang_Daemons != NULL); |
| 2076 | DCHECK(WellKnownClasses::java_lang_Daemons_requestHeapTrim != NULL); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 2077 | env->CallStaticVoidMethod(WellKnownClasses::java_lang_Daemons, |
| 2078 | WellKnownClasses::java_lang_Daemons_requestHeapTrim); |
Elliott Hughes | 8cf5bc0 | 2012-02-02 16:32:16 -0800 | [diff] [blame] | 2079 | CHECK(!env->ExceptionCheck()); |
| 2080 | } |
| 2081 | |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 2082 | } // namespace art |