From: hpayer@chromium.org Date: Fri, 22 Aug 2014 11:14:17 +0000 (+0000) Subject: Add finalize sweeping event to GCIdleTimeHandler. X-Git-Tag: upstream/4.7.83~7461 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=92859d3c818bfd057f5c055a8c183aa723a54418;p=platform%2Fupstream%2Fv8.git Add finalize sweeping event to GCIdleTimeHandler. BUG= R=ulan@chromium.org Review URL: https://codereview.chromium.org/479693004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23302 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- diff --git a/src/heap/gc-idle-time-handler.cc b/src/heap/gc-idle-time-handler.cc index 90f916e..e5ed823 100644 --- a/src/heap/gc-idle-time-handler.cc +++ b/src/heap/gc-idle-time-handler.cc @@ -10,7 +10,6 @@ namespace v8 { namespace internal { const double GCIdleTimeHandler::kConservativeTimeRatio = 0.9; -const size_t GCIdleTimeHandler::kMaxMarkCompactTimeInMs = 1000000; size_t GCIdleTimeHandler::EstimateMarkingStepSize( @@ -30,8 +29,7 @@ size_t GCIdleTimeHandler::EstimateMarkingStepSize( if (marking_step_size > kMaximumMarkingStepSize) return kMaximumMarkingStepSize; - return static_cast(marking_step_size * - GCIdleTimeHandler::kConservativeTimeRatio); + return static_cast(marking_step_size * kConservativeTimeRatio); } @@ -45,7 +43,7 @@ size_t GCIdleTimeHandler::EstimateMarkCompactTime( } -GCIdleTimeAction GCIdleTimeHandler::Compute(int idle_time_in_ms, +GCIdleTimeAction GCIdleTimeHandler::Compute(size_t idle_time_in_ms, HeapState heap_state, GCTracer* gc_tracer) { if (IsIdleRoundFinished()) { @@ -58,8 +56,8 @@ GCIdleTimeAction GCIdleTimeHandler::Compute(int idle_time_in_ms, if (heap_state.incremental_marking_stopped) { size_t speed = static_cast(gc_tracer->MarkCompactSpeedInBytesPerMillisecond()); - if (idle_time_in_ms >= static_cast(EstimateMarkCompactTime( - heap_state.size_of_objects, speed))) { + if (idle_time_in_ms >= + EstimateMarkCompactTime(heap_state.size_of_objects, speed)) { // If there are no more than two GCs left in this idle round and we are // allowed to do a full GC, then make those GCs full in order to compact // the code space. @@ -76,6 +74,12 @@ GCIdleTimeAction GCIdleTimeHandler::Compute(int idle_time_in_ms, return GCIdleTimeAction::Nothing(); } } + // TODO(hpayer): Estimate finalize sweeping time. + if (heap_state.sweeping_in_progress && + idle_time_in_ms >= kMinTimeForFinalizeSweeping) { + return GCIdleTimeAction::FinalizeSweeping(); + } + intptr_t speed = gc_tracer->IncrementalMarkingSpeedInBytesPerMillisecond(); size_t step_size = static_cast(EstimateMarkingStepSize(idle_time_in_ms, speed)); diff --git a/src/heap/gc-idle-time-handler.h b/src/heap/gc-idle-time-handler.h index 5a842a8..bc196ce 100644 --- a/src/heap/gc-idle-time-handler.h +++ b/src/heap/gc-idle-time-handler.h @@ -14,7 +14,8 @@ enum GCIdleTimeActionType { DO_NOTHING, DO_INCREMENTAL_MARKING, DO_SCAVENGE, - DO_FULL_GC + DO_FULL_GC, + DO_FINALIZE_SWEEPING }; @@ -26,18 +27,21 @@ class GCIdleTimeAction { result.parameter = 0; return result; } + static GCIdleTimeAction IncrementalMarking(intptr_t step_size) { GCIdleTimeAction result; result.type = DO_INCREMENTAL_MARKING; result.parameter = step_size; return result; } + static GCIdleTimeAction Scavenge() { GCIdleTimeAction result; result.type = DO_SCAVENGE; result.parameter = 0; return result; } + static GCIdleTimeAction FullGC() { GCIdleTimeAction result; result.type = DO_FULL_GC; @@ -45,6 +49,13 @@ class GCIdleTimeAction { return result; } + static GCIdleTimeAction FinalizeSweeping() { + GCIdleTimeAction result; + result.type = DO_FINALIZE_SWEEPING; + result.parameter = 0; + return result; + } + GCIdleTimeActionType type; intptr_t parameter; }; @@ -72,20 +83,25 @@ class GCIdleTimeHandler { static const size_t kInitialConservativeMarkCompactSpeed = 2 * MB; // Maximum mark-compact time returned by EstimateMarkCompactTime. - static const size_t kMaxMarkCompactTimeInMs; + static const size_t kMaxMarkCompactTimeInMs = 1000000; + + // Minimum time to finalize sweeping phase. The main thread may wait for + // sweeper threads. + static const size_t kMinTimeForFinalizeSweeping = 100; struct HeapState { int contexts_disposed; size_t size_of_objects; bool incremental_marking_stopped; bool can_start_incremental_marking; + bool sweeping_in_progress; }; GCIdleTimeHandler() : mark_compacts_since_idle_round_started_(0), scavenges_since_last_idle_round_(0) {} - GCIdleTimeAction Compute(int idle_time_in_ms, HeapState heap_state, + GCIdleTimeAction Compute(size_t idle_time_in_ms, HeapState heap_state, GCTracer* gc_tracer); void NotifyIdleMarkCompact() { diff --git a/src/heap/heap.cc b/src/heap/heap.cc index f3f539d..a29b767 100644 --- a/src/heap/heap.cc +++ b/src/heap/heap.cc @@ -4296,6 +4296,8 @@ bool Heap::IdleNotification(int idle_time_in_ms) { heap_state.incremental_marking_stopped = incremental_marking()->IsStopped(); // TODO(ulan): Start incremental marking only for large heaps. heap_state.can_start_incremental_marking = true; + heap_state.sweeping_in_progress = + mark_compact_collector()->sweeping_in_progress(); GCIdleTimeAction action = gc_idle_time_handler_.Compute(idle_time_in_ms, heap_state, tracer()); @@ -4321,18 +4323,12 @@ bool Heap::IdleNotification(int idle_time_in_ms) { case DO_SCAVENGE: CollectGarbage(NEW_SPACE, "idle notification: scavenge"); break; + case DO_FINALIZE_SWEEPING: + mark_compact_collector()->EnsureSweepingCompleted(); case DO_NOTHING: result = true; break; } - // If the IdleNotifcation is called with a large hint we will wait for - // the sweepter threads here. - // TODO(ulan): move this in GCIdleTimeHandler. - const int kMinHintForFullGC = 100; - if (idle_time_in_ms >= kMinHintForFullGC && - mark_compact_collector()->sweeping_in_progress()) { - mark_compact_collector()->EnsureSweepingCompleted(); - } return result; }