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

@@ -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<size_t>(gc_tracer->MarkCompactSpeedInBytesPerMillisecond());
-    if (idle_time_in_ms >= static_cast<int>(EstimateMarkCompactTime(
+    if (idle_time_in_ms >=
-                               heap_state.size_of_objects, speed))) {
+        static_cast<int>(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 ||
+      if (contexts_disposed > 0 || remaining_mark_sweeps <= 2) {
-          !heap_state.can_start_incremental_marking) {
         return GCIdleTimeAction::FullGC();
       }
     }
-    if (!heap_state.can_start_incremental_marking) {
-      return GCIdleTimeAction::Nothing();
-    }
   }
   intptr_t speed = gc_tracer->IncrementalMarkingSpeedInBytesPerMillisecond();
   size_t step_size =

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() {

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;
+  GCIdleTimeAction action = gc_idle_time_handler_.Compute(
-  heap_state.contexts_disposed = contexts_disposed_;
+      idle_time_in_ms, contexts_disposed_, static_cast<size_t>(SizeOfObjects()),
-  heap_state.size_of_objects = static_cast<size_t>(SizeOfObjects());
+      incremental_marking()->IsStopped(), tracer());
-  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());
-
   contexts_disposed_ = 0;
   bool result = false;
   switch (action.type) {

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) {