From 43feb7f644c6543e63b3add5d3f865df571c2c20 Mon Sep 17 00:00:00 2001 From: "machenbach@chromium.org" Date: Thu, 21 Aug 2014 19:55:27 +0000 Subject: [PATCH] Revert "Start incremental marking in idle time handler only if it is worthwhile." This reverts commit r23285 for breaking cctest/test-api/Regress2107. TBR=ulan@chromium.org, hpayer@chromium.org, yangguo@chromium.org Review URL: https://codereview.chromium.org/494203002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23286 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/heap/gc-idle-time-handler.cc | 18 ++++++++---------- src/heap/gc-idle-time-handler.h | 12 +++--------- src/heap/heap.cc | 22 +++++----------------- src/heap/heap.h | 2 -- 4 files changed, 16 insertions(+), 38 deletions(-) diff --git a/src/heap/gc-idle-time-handler.cc b/src/heap/gc-idle-time-handler.cc index 90f916e2f4..a2e08b28c5 100644 --- a/src/heap/gc-idle-time-handler.cc +++ b/src/heap/gc-idle-time-handler.cc @@ -46,20 +46,22 @@ size_t GCIdleTimeHandler::EstimateMarkCompactTime( GCIdleTimeAction GCIdleTimeHandler::Compute(int idle_time_in_ms, - HeapState heap_state, + int contexts_disposed, + size_t size_of_objects, + bool incremental_marking_stopped, GCTracer* gc_tracer) { if (IsIdleRoundFinished()) { - if (EnoughGarbageSinceLastIdleRound() || heap_state.contexts_disposed > 0) { + if (EnoughGarbageSinceLastIdleRound() || contexts_disposed > 0) { StartIdleRound(); } else { return GCIdleTimeAction::Nothing(); } } - if (heap_state.incremental_marking_stopped) { + if (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 >= + static_cast(EstimateMarkCompactTime(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. @@ -67,14 +69,10 @@ GCIdleTimeAction GCIdleTimeHandler::Compute(int idle_time_in_ms, // can get rid of this special case and always start incremental marking. int remaining_mark_sweeps = kMaxMarkCompactsInIdleRound - mark_compacts_since_idle_round_started_; - if (heap_state.contexts_disposed > 0 || remaining_mark_sweeps <= 2 || - !heap_state.can_start_incremental_marking) { + if (contexts_disposed > 0 || remaining_mark_sweeps <= 2) { return GCIdleTimeAction::FullGC(); } } - if (!heap_state.can_start_incremental_marking) { - return GCIdleTimeAction::Nothing(); - } } intptr_t speed = gc_tracer->IncrementalMarkingSpeedInBytesPerMillisecond(); size_t step_size = diff --git a/src/heap/gc-idle-time-handler.h b/src/heap/gc-idle-time-handler.h index 5a842a8597..76cdb9f21c 100644 --- a/src/heap/gc-idle-time-handler.h +++ b/src/heap/gc-idle-time-handler.h @@ -49,7 +49,6 @@ class GCIdleTimeAction { intptr_t parameter; }; - class GCTracer; // The idle time handler makes decisions about which garbage collection @@ -74,18 +73,13 @@ class GCIdleTimeHandler { // Maximum mark-compact time returned by EstimateMarkCompactTime. static const size_t kMaxMarkCompactTimeInMs; - struct HeapState { - int contexts_disposed; - size_t size_of_objects; - bool incremental_marking_stopped; - bool can_start_incremental_marking; - }; - 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(int idle_time_in_ms, int contexts_disposed, + size_t size_of_objects, + bool incremental_marking_stopped, GCTracer* gc_tracer); void NotifyIdleMarkCompact() { diff --git a/src/heap/heap.cc b/src/heap/heap.cc index ae730374c6..c7e1de398e 100644 --- a/src/heap/heap.cc +++ b/src/heap/heap.cc @@ -845,7 +845,8 @@ bool Heap::CollectGarbage(GarbageCollector collector, const char* gc_reason, // Start incremental marking for the next cycle. The heap snapshot // generator needs incremental marking to stay off after it aborted. if (!mark_compact_collector()->abort_incremental_marking() && - WorthActivatingIncrementalMarking()) { + incremental_marking()->IsStopped() && + incremental_marking()->WorthActivating() && NextGCIsLikelyToBeFull()) { incremental_marking()->Start(); } @@ -4276,12 +4277,6 @@ void Heap::AdvanceIdleIncrementalMarking(intptr_t step_size) { } -bool Heap::WorthActivatingIncrementalMarking() { - return incremental_marking()->IsStopped() && - incremental_marking()->WorthActivating() && NextGCIsLikelyToBeFull(); -} - - bool Heap::IdleNotification(int idle_time_in_ms) { // If incremental marking is off, we do not perform idle notification. if (!FLAG_incremental_marking) return true; @@ -4290,16 +4285,9 @@ bool Heap::IdleNotification(int idle_time_in_ms) { HistogramTimerScope idle_notification_scope( isolate_->counters()->gc_idle_notification()); - GCIdleTimeHandler::HeapState heap_state; - heap_state.contexts_disposed = contexts_disposed_; - heap_state.size_of_objects = static_cast(SizeOfObjects()); - heap_state.incremental_marking_stopped = incremental_marking()->IsStopped(); - heap_state.can_start_incremental_marking = - WorthActivatingIncrementalMarking(); - - GCIdleTimeAction action = - gc_idle_time_handler_.Compute(idle_time_in_ms, heap_state, tracer()); - + GCIdleTimeAction action = gc_idle_time_handler_.Compute( + idle_time_in_ms, contexts_disposed_, static_cast(SizeOfObjects()), + incremental_marking()->IsStopped(), tracer()); contexts_disposed_ = 0; bool result = false; switch (action.type) { diff --git a/src/heap/heap.h b/src/heap/heap.h index 1b56f257d4..dacf916edc 100644 --- a/src/heap/heap.h +++ b/src/heap/heap.h @@ -1929,8 +1929,6 @@ class Heap { void AdvanceIdleIncrementalMarking(intptr_t step_size); - bool WorthActivatingIncrementalMarking(); - void ClearObjectStats(bool clear_last_time_stats = false); void set_weak_object_to_code_table(Object* value) {