Move IncrementalRecordWrite to a stub.

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 11 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
 #include "incremental-marking.h"
 
+#include "code-stubs.h"
 
 namespace v8 {
 namespace internal {
 
 IncrementalMarking::State IncrementalMarking::state_ = STOPPED;
 MarkingStack IncrementalMarking::marking_stack_;
 
 static intptr_t allocated = 0;
 
 class IncrementalMarkingMarkingVisitor : public ObjectVisitor {
@@ skipping 73 matching lines @@
 
   static void VerifyMarkbitsAreClean() {
     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;
+#else
+  static const intptr_t kActivationThreshold = 0;

[Erik Corry, 2011/03/02 12:34:06]

Perhaps worth setting this to some low level so that some debug tests run with
incremental marking and some without.

[Vyacheslav Egorov (Chromium), 2011/03/02 15:11:32]

For now let's always resort to incremental marking to get test coverage.
I have added todo

+#endif
+
+  return FLAG_incremental_marking &&
+      Heap::PromotedSpaceSize() > kActivationThreshold;
+}
+
+
+static void PatchStubs(bool enable) {

[Erik Corry, 2011/03/02 12:34:06]

This should be called something that reveals what sort of stubs it patches.

[Vyacheslav Egorov (Chromium), 2011/03/02 15:11:32]

Done.

+  NumberDictionary* stubs = Heap::code_stubs();
+
+

[Erik Corry, 2011/03/02 12:34:06]

Blank line.

[Vyacheslav Egorov (Chromium), 2011/03/02 15:11:32]

Done.

+  int capacity = stubs->Capacity();
+  for (int i = 0; i < capacity; i++) {
+    Object* k = stubs->KeyAt(i);
+    if (stubs->IsKey(k)) {
+      uint32_t key = NumberToUint32(k);
+
+      if (CodeStub::MajorKeyFromKey(key) ==
+          CodeStub::IncrementalMarkingRecordWrite) {
+        Object* e = stubs->ValueAt(i);
+        if (e->IsJSGlobalPropertyCell()) {
+          e = JSGlobalPropertyCell::cast(e)->value();

[Erik Corry, 2011/03/02 12:34:06]

WTF?

[Vyacheslav Egorov (Chromium), 2011/03/02 15:11:32]

Done.

+        }
+
+        if (e->IsCode()) {
+          Code* stub = Code::cast(e);
+          *stub->instruction_start() = enable ? 0x90 : 0xc3;

[Erik Corry, 2011/03/02 12:34:06]

These should be constants from assembler-ia32.h 

Also you should assert that the old value was the opposite.

[Vyacheslav Egorov (Chromium), 2011/03/02 15:11:32]

Done.

+        }
+      }
+    }
+  }
+}
+
+
 void IncrementalMarking::Start() {
   if (FLAG_trace_incremental_marking) {
     PrintF("[IncrementalMarking] Start\n");
   }
   ASSERT(FLAG_incremental_marking);
   ASSERT(state_ == STOPPED);
   state_ = MARKING;
 
+  PatchStubs(true);
+
   // Initialize marking stack.
   marking_stack_.Initialize(Heap::new_space()->FromSpaceLow(),
                             Heap::new_space()->FromSpaceHigh());
 
   // Clear markbits.
   Address new_space_top = Heap::new_space()->top();
   Address new_space_bottom = Heap::new_space()->bottom();
 
   Marking::ClearRange(new_space_bottom,
                       static_cast<int>(new_space_top - new_space_bottom));
@@ skipping 31 matching lines @@
     if (FLAG_trace_incremental_marking) {
       PrintF("[IncrementalMarking] Complete (hurry)\n");
     }
   }
 }
 
 
 void IncrementalMarking::Finalize() {
   Hurry();
   state_ = STOPPED;
+  PatchStubs(false);
   ASSERT(marking_stack_.is_empty());
 }
 
 
 void IncrementalMarking::MarkingComplete() {
   state_ = COMPLETE;
   // We completed marking.
   if (FLAG_trace_incremental_marking) {
     PrintF("[IncrementalMarking] Complete (normal)\n");
   }
@@ skipping 31 matching lines @@
                static_cast<int>(end - start));
       }
       allocated = 0;
       if (marking_stack_.is_empty()) MarkingComplete();
     }
   }
 }
 
 
 } }  // namespace v8::internal