On store buffer overflow we mark individidual pages for...

src/incremental-marking.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 21 matching lines @@
 #include "code-stubs.h"
 
 namespace v8 {
 namespace internal {
 
 IncrementalMarking::State IncrementalMarking::state_ = STOPPED;
 MarkingStack IncrementalMarking::marking_stack_;
 
 double IncrementalMarking::steps_took_ = 0;
 int IncrementalMarking::steps_count_ = 0;
+bool IncrementalMarking::should_hurry_ = false;
 
 static intptr_t allocated = 0;
 
 class IncrementalMarkingMarkingVisitor : public ObjectVisitor {
  public:
   void VisitPointer(Object** p) {
     MarkObjectByPointer(p);
   }
 
   void VisitPointers(Object** start, Object** end) {
@@ skipping 86 matching lines @@
     VerifyMarkbitsAreClean(Heap::old_pointer_space());
     VerifyMarkbitsAreClean(Heap::old_data_space());
     VerifyMarkbitsAreClean(Heap::code_space());
     VerifyMarkbitsAreClean(Heap::cell_space());
     VerifyMarkbitsAreClean(Heap::map_space());
   }
 #endif
 
 bool IncrementalMarking::WorthActivating() {
 #ifndef DEBUG
-  static const intptr_t kActivationThreshold = 20*MB;
+  static const intptr_t kActivationThreshold = 8 * MB;
 #else
   // TODO(gc) consider setting this to some low level so that some
   // debug tests run with incremental marking and some without.
   static const intptr_t kActivationThreshold = 0;
 #endif
 
   return FLAG_incremental_marking &&
       Heap::PromotedSpaceSize() > kActivationThreshold;
 }
 
@@ skipping 146 matching lines @@
   Hurry();
   state_ = STOPPED;
   ResetStepCounters();
   PatchIncrementalMarkingRecordWriteStubs(false);
   ASSERT(marking_stack_.is_empty());
 }
 
 
 void IncrementalMarking::MarkingComplete() {
   state_ = COMPLETE;
+  // We will set the stack guard to request a GC now.  This will mean the rest
+  // of the GC gets performed as soon as possible (we can't do a GC here in a
+  // record-write context).  If a few things get allocated between now and then
+  // that shouldn't make us do a scavenge and keep being incremental, so we set
+  // the should-hurry flag to indicate that there can't be much work left to do.
+  set_should_hurry(true);
   if (FLAG_trace_incremental_marking) {
     PrintF("[IncrementalMarking] Complete (normal).\n");
   }
   StackGuard::RequestGC();
 }
 
 
 void IncrementalMarking::Step(intptr_t allocated_bytes) {
   if (state_ == MARKING &&
       Heap::gc_state() == Heap::NOT_IN_GC &&
@@ skipping 36 matching lines @@
         double end = OS::TimeCurrentMillis();
         steps_took_ += (end - start);
         steps_count_++;
       }
     }
   }
 }
 
 
 } }  // namespace v8::internal