[heap] Reland: Use store buffer for writes coming from mutator.

src/heap/store-buffer.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_STORE_BUFFER_H_
 #define V8_STORE_BUFFER_H_
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/base/platform/platform.h"
 #include "src/cancelable-task.h"
 #include "src/globals.h"
+#include "src/heap/remembered-set.h"
 #include "src/heap/slot-set.h"
 
 namespace v8 {
 namespace internal {
 
 // Intermediate buffer that accumulates old-to-new stores from the generated
 // code. Moreover, it stores invalid old-to-new slots with two entries.
 // The first is a tagged address of the start of the invalid range, the second
 // one is the end address of the invalid range or null if there is just one slot
 // that needs to be removed from the remembered set. On buffer overflow the
 // slots are moved to the remembered set.
 class StoreBuffer {
  public:
   static const int kStoreBufferSize = 1 << (14 + kPointerSizeLog2);
   static const int kStoreBufferMask = kStoreBufferSize - 1;
   static const int kStoreBuffers = 2;
   static const intptr_t kDeletionTag = 1;
 
-  static void StoreBufferOverflow(Isolate* isolate);
+  V8_EXPORT_PRIVATE static void StoreBufferOverflow(Isolate* isolate);
 
   explicit StoreBuffer(Heap* heap);
   void SetUp();
   void TearDown();
 
   // Used to add entries from generated code.
   inline Address* top_address() { return reinterpret_cast<Address*>(&top_); }
 
   // Moves entries from a specific store buffer to the remembered set. This
   // method takes a lock.
@@ skipping 15 matching lines @@
   inline Address UnmarkDeletionAddress(Address address) {
     return reinterpret_cast<Address>(reinterpret_cast<intptr_t>(address) &
                                      ~kDeletionTag);
   }
 
   // If we only want to delete a single slot, end should be set to null which
   // will be written into the second field. When processing the store buffer
   // the more efficient Remove method will be called in this case.
   void DeleteEntry(Address start, Address end = nullptr);
 
+  void InsertEntry(Address slot) {
+    // Insertions coming from the GC are directly inserted into the remembered
+    // set. Insertions coming from the runtime are added to the store buffer to
+    // allow concurrent processing.
+    if (heap_->gc_state() == Heap::NOT_IN_GC) {
+      if (top_ + sizeof(Address) > limit_[current_]) {
+        StoreBufferOverflow(heap_->isolate());
+      }
+      *top_ = slot;
+      top_++;
+    } else {
+      // In GC the store buffer has to be empty at any time.
+      DCHECK(Empty());
+      RememberedSet<OLD_TO_NEW>::Insert(Page::FromAddress(slot), slot);
+    }
+  }
+
   // Used by the concurrent processing thread to transfer entries from the
   // store buffer to the remembered set.
   void ConcurrentlyProcessStoreBuffer();
 
   bool Empty() {
     for (int i = 0; i < kStoreBuffers; i++) {
       if (lazy_top_[i]) {
         return false;
       }
     }
@@ skipping 47 matching lines @@
   // Points to the current buffer in use.
   int current_;
 
   base::VirtualMemory* virtual_memory_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_STORE_BUFFER_H_