Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 1 | // Copyright 2014 the V8 project authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include "src/heap/gc-idle-time-handler.h" |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 6 | |
| 7 | #include "src/flags.h" |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 8 | #include "src/heap/gc-tracer.h" |
| 9 | #include "src/utils.h" |
| 10 | |
| 11 | namespace v8 { |
| 12 | namespace internal { |
| 13 | |
| 14 | const double GCIdleTimeHandler::kConservativeTimeRatio = 0.9; |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 15 | const size_t GCIdleTimeHandler::kMaxFinalIncrementalMarkCompactTimeInMs = 1000; |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 16 | const double GCIdleTimeHandler::kHighContextDisposalRate = 100; |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 17 | const size_t GCIdleTimeHandler::kMinTimeForOverApproximatingWeakClosureInMs = 1; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 18 | |
| 19 | |
| 20 | void GCIdleTimeAction::Print() { |
| 21 | switch (type) { |
| 22 | case DONE: |
| 23 | PrintF("done"); |
| 24 | break; |
| 25 | case DO_NOTHING: |
| 26 | PrintF("no action"); |
| 27 | break; |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 28 | case DO_INCREMENTAL_STEP: |
| 29 | PrintF("incremental step"); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 30 | if (additional_work) { |
| 31 | PrintF("; finalized marking"); |
| 32 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 33 | break; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 34 | case DO_FULL_GC: |
| 35 | PrintF("full GC"); |
| 36 | break; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 37 | } |
| 38 | } |
| 39 | |
| 40 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 41 | void GCIdleTimeHeapState::Print() { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 42 | PrintF("contexts_disposed=%d ", contexts_disposed); |
| 43 | PrintF("contexts_disposal_rate=%f ", contexts_disposal_rate); |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame] | 44 | PrintF("size_of_objects=%" V8_SIZET_PREFIX V8_PTR_PREFIX "d ", |
| 45 | size_of_objects); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 46 | PrintF("incremental_marking_stopped=%d ", incremental_marking_stopped); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 47 | } |
| 48 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 49 | size_t GCIdleTimeHandler::EstimateMarkingStepSize( |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame] | 50 | double idle_time_in_ms, double marking_speed_in_bytes_per_ms) { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 51 | DCHECK(idle_time_in_ms > 0); |
| 52 | |
| 53 | if (marking_speed_in_bytes_per_ms == 0) { |
| 54 | marking_speed_in_bytes_per_ms = kInitialConservativeMarkingSpeed; |
| 55 | } |
| 56 | |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame] | 57 | double marking_step_size = marking_speed_in_bytes_per_ms * idle_time_in_ms; |
| 58 | if (marking_step_size >= kMaximumMarkingStepSize) { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 59 | return kMaximumMarkingStepSize; |
| 60 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 61 | return static_cast<size_t>(marking_step_size * kConservativeTimeRatio); |
| 62 | } |
| 63 | |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame] | 64 | double GCIdleTimeHandler::EstimateFinalIncrementalMarkCompactTime( |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 65 | size_t size_of_objects, |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame] | 66 | double final_incremental_mark_compact_speed_in_bytes_per_ms) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 67 | if (final_incremental_mark_compact_speed_in_bytes_per_ms == 0) { |
| 68 | final_incremental_mark_compact_speed_in_bytes_per_ms = |
| 69 | kInitialConservativeFinalIncrementalMarkCompactSpeed; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 70 | } |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame] | 71 | double result = |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 72 | size_of_objects / final_incremental_mark_compact_speed_in_bytes_per_ms; |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame] | 73 | return Min<double>(result, kMaxFinalIncrementalMarkCompactTimeInMs); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 74 | } |
| 75 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 76 | bool GCIdleTimeHandler::ShouldDoContextDisposalMarkCompact( |
| 77 | int contexts_disposed, double contexts_disposal_rate) { |
| 78 | return contexts_disposed > 0 && contexts_disposal_rate > 0 && |
| 79 | contexts_disposal_rate < kHighContextDisposalRate; |
| 80 | } |
| 81 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 82 | bool GCIdleTimeHandler::ShouldDoFinalIncrementalMarkCompact( |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame] | 83 | double idle_time_in_ms, size_t size_of_objects, |
| 84 | double final_incremental_mark_compact_speed_in_bytes_per_ms) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 85 | return idle_time_in_ms >= |
| 86 | EstimateFinalIncrementalMarkCompactTime( |
| 87 | size_of_objects, |
| 88 | final_incremental_mark_compact_speed_in_bytes_per_ms); |
| 89 | } |
| 90 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 91 | bool GCIdleTimeHandler::ShouldDoOverApproximateWeakClosure( |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame] | 92 | double idle_time_in_ms) { |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 93 | // TODO(jochen): Estimate the time it will take to build the object groups. |
| 94 | return idle_time_in_ms >= kMinTimeForOverApproximatingWeakClosureInMs; |
| 95 | } |
| 96 | |
| 97 | |
| 98 | GCIdleTimeAction GCIdleTimeHandler::NothingOrDone(double idle_time_in_ms) { |
| 99 | if (idle_time_in_ms >= kMinBackgroundIdleTime) { |
| 100 | return GCIdleTimeAction::Nothing(); |
| 101 | } |
| 102 | if (idle_times_which_made_no_progress_ >= kMaxNoProgressIdleTimes) { |
| 103 | return GCIdleTimeAction::Done(); |
| 104 | } else { |
| 105 | idle_times_which_made_no_progress_++; |
| 106 | return GCIdleTimeAction::Nothing(); |
| 107 | } |
| 108 | } |
| 109 | |
| 110 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 111 | // The following logic is implemented by the controller: |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 112 | // (1) If we don't have any idle time, do nothing, unless a context was |
| 113 | // disposed, incremental marking is stopped, and the heap is small. Then do |
| 114 | // a full GC. |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 115 | // (2) If the context disposal rate is high and we cannot perform a full GC, |
| 116 | // we do nothing until the context disposal rate becomes lower. |
| 117 | // (3) If the new space is almost full and we can affort a scavenge or if the |
| 118 | // next scavenge will very likely take long, then a scavenge is performed. |
| 119 | // (4) If sweeping is in progress and we received a large enough idle time |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 120 | // request, we finalize sweeping here. |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 121 | // (5) If incremental marking is in progress, we perform a marking step. Note, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 122 | // that this currently may trigger a full garbage collection. |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 123 | GCIdleTimeAction GCIdleTimeHandler::Compute(double idle_time_in_ms, |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 124 | GCIdleTimeHeapState heap_state) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 125 | if (static_cast<int>(idle_time_in_ms) <= 0) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 126 | if (heap_state.incremental_marking_stopped) { |
| 127 | if (ShouldDoContextDisposalMarkCompact( |
| 128 | heap_state.contexts_disposed, |
| 129 | heap_state.contexts_disposal_rate)) { |
| 130 | return GCIdleTimeAction::FullGC(); |
| 131 | } |
| 132 | } |
| 133 | return GCIdleTimeAction::Nothing(); |
| 134 | } |
| 135 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 136 | // We are in a context disposal GC scenario. Don't do anything if we do not |
| 137 | // get the right idle signal. |
| 138 | if (ShouldDoContextDisposalMarkCompact(heap_state.contexts_disposed, |
| 139 | heap_state.contexts_disposal_rate)) { |
| 140 | return NothingOrDone(idle_time_in_ms); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 141 | } |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 142 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 143 | if (!FLAG_incremental_marking || heap_state.incremental_marking_stopped) { |
| 144 | return GCIdleTimeAction::Done(); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 145 | } |
| 146 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 147 | return GCIdleTimeAction::IncrementalStep(); |
| 148 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 149 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 150 | |
| 151 | } // namespace internal |
| 152 | } // namespace v8 |