[heap] Parallel newspace evacuation, semispace copy, and compaction \o/

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"
@@ skipping 15 matching lines @@
   explicit StoreBuffer(Heap* heap);
 
   static void StoreBufferOverflow(Isolate* isolate);
 
   void SetUp();
   void TearDown();
 
   // This is used to add addresses to the store buffer non-concurrently.
   inline void Mark(Address addr);
 
-  // This is used to add addresses to the store buffer when multiple threads
-  // may operate on the store buffer.
-  inline void MarkSynchronized(Address addr);
-
   // This is used by the heap traversal to enter the addresses into the store
   // buffer that should still be in the store buffer after GC.  It enters
   // addresses directly into the old buffer because the GC starts by wiping the
   // old buffer and thereafter only visits each cell once so there is no need
   // to attempt to remove any dupes.  During the first part of a GC we
   // are using the store buffer to access the old spaces and at the same time
   // we are rebuilding the store buffer using this function.  There is, however
   // no issue of overwriting the buffer we are iterating over, because this
   // stage of the scavenge can only reduce the number of addresses in the store
   // buffer (some objects are promoted so pointers to them do not need to be in
@@ skipping 159 matching lines @@
   }
 
   ~DontMoveStoreBufferEntriesScope() {
     store_buffer_->may_move_store_buffer_entries_ = stored_state_;
   }
 
  private:
   StoreBuffer* store_buffer_;
   bool stored_state_;
 };
+
+
+class LocalStoreBuffer BASE_EMBEDDED {
+ public:
+  LocalStoreBuffer() : top_(new Node(nullptr)) {}
+
+  ~LocalStoreBuffer() {
+    Node* current = top_;
+    while (current != nullptr) {
+      Node* tmp = current->next;
+      delete current;
+      current = tmp;
+    }
+  }
+
+  inline void Record(Address addr);
+  inline void Process(StoreBuffer* store_buffer);
+
+ private:
+  static const int kBufferSize = 16 * KB;
+
+  struct Node : Malloced {
+    explicit Node(Node* next_node) : next(next_node), count(0) {}
+
+    inline bool is_full() { return count == kBufferSize; }
+
+    Node* next;
+    Address buffer[kBufferSize];
+    int count;
+  };
+
+  Node* top_;
+};
+
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_STORE_BUFFER_H_