From 80cd0fbda54ff22570b3c354204a89065b25cee8 Mon Sep 17 00:00:00 2001 From: "yangguo@chromium.org" Date: Fri, 22 Aug 2014 11:36:23 +0000 Subject: [PATCH] Revert "Add finalize sweeping event to GCIdleTimeHandler." This reverts r23302. TBR=hpayer@chromium.org Review URL: https://codereview.chromium.org/500483002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23304 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/heap/gc-idle-time-handler.cc | 16 ++++++---------- src/heap/gc-idle-time-handler.h | 22 +++------------------- src/heap/heap.cc | 12 ++++++++---- 3 files changed, 17 insertions(+), 33 deletions(-) diff --git a/src/heap/gc-idle-time-handler.cc b/src/heap/gc-idle-time-handler.cc index e5ed823..90f916e 100644 --- a/src/heap/gc-idle-time-handler.cc +++ b/src/heap/gc-idle-time-handler.cc @@ -10,6 +10,7 @@ namespace v8 { namespace internal { const double GCIdleTimeHandler::kConservativeTimeRatio = 0.9; +const size_t GCIdleTimeHandler::kMaxMarkCompactTimeInMs = 1000000; size_t GCIdleTimeHandler::EstimateMarkingStepSize( @@ -29,7 +30,8 @@ size_t GCIdleTimeHandler::EstimateMarkingStepSize( if (marking_step_size > kMaximumMarkingStepSize) return kMaximumMarkingStepSize; - return static_cast(marking_step_size * kConservativeTimeRatio); + return static_cast(marking_step_size * + GCIdleTimeHandler::kConservativeTimeRatio); } @@ -43,7 +45,7 @@ size_t GCIdleTimeHandler::EstimateMarkCompactTime( } -GCIdleTimeAction GCIdleTimeHandler::Compute(size_t idle_time_in_ms, +GCIdleTimeAction GCIdleTimeHandler::Compute(int idle_time_in_ms, HeapState heap_state, GCTracer* gc_tracer) { if (IsIdleRoundFinished()) { @@ -56,8 +58,8 @@ GCIdleTimeAction GCIdleTimeHandler::Compute(size_t idle_time_in_ms, if (heap_state.incremental_marking_stopped) { size_t speed = static_cast(gc_tracer->MarkCompactSpeedInBytesPerMillisecond()); - if (idle_time_in_ms >= - EstimateMarkCompactTime(heap_state.size_of_objects, speed)) { + if (idle_time_in_ms >= static_cast(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. @@ -74,12 +76,6 @@ GCIdleTimeAction GCIdleTimeHandler::Compute(size_t 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 bc196ce..5a842a8 100644 --- a/src/heap/gc-idle-time-handler.h +++ b/src/heap/gc-idle-time-handler.h @@ -14,8 +14,7 @@ enum GCIdleTimeActionType { DO_NOTHING, DO_INCREMENTAL_MARKING, DO_SCAVENGE, - DO_FULL_GC, - DO_FINALIZE_SWEEPING + DO_FULL_GC }; @@ -27,21 +26,18 @@ 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; @@ -49,13 +45,6 @@ class GCIdleTimeAction { return result; } - static GCIdleTimeAction FinalizeSweeping() { - GCIdleTimeAction result; - result.type = DO_FINALIZE_SWEEPING; - result.parameter = 0; - return result; - } - GCIdleTimeActionType type; intptr_t parameter; }; @@ -83,25 +72,20 @@ class GCIdleTimeHandler { static const size_t kInitialConservativeMarkCompactSpeed = 2 * MB; // Maximum mark-compact time returned by EstimateMarkCompactTime. - 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; + static const size_t kMaxMarkCompactTimeInMs; 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(size_t idle_time_in_ms, HeapState heap_state, + GCIdleTimeAction Compute(int 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 a29b767..f3f539d 100644 --- a/src/heap/heap.cc +++ b/src/heap/heap.cc @@ -4296,8 +4296,6 @@ 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()); @@ -4323,12 +4321,18 @@ 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; } -- 2.7.4