Synchronize on concurrent store buffer entries.

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 @@
 // between spaces.
 class StoreBuffer {
  public:
   explicit StoreBuffer(Heap* heap);
 
   static void StoreBufferOverflow(Isolate* isolate);
 
   void SetUp();
   void TearDown();
 
-  // This is used by the mutator to enter addresses into the store buffer.
+  // 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 73 matching lines @@
 
   base::VirtualMemory* virtual_memory_;
 
   // Two hash sets used for filtering.
   // If address is in the hash set then it is guaranteed to be in the
   // old part of the store buffer.
   uintptr_t* hash_set_1_;
   uintptr_t* hash_set_2_;
   bool hash_sets_are_empty_;
 
+  // Used for synchronization of concurrent store buffer access.
+  base::Mutex mutex_;
+
   void ClearFilteringHashSets();
 
   bool SpaceAvailable(intptr_t space_needed);
   void ExemptPopularPages(int prime_sample_step, int threshold);
 
   void ProcessOldToNewSlot(Address slot_address,
                            ObjectSlotCallback slot_callback);
 
   void FindPointersToNewSpaceInRegion(Address start, Address end,
                                       ObjectSlotCallback slot_callback);
@@ skipping 75 matching lines @@
   }
 
  private:
   StoreBuffer* store_buffer_;
   bool stored_state_;
 };
 }
 }  // namespace v8::internal
 
 #endif  // V8_STORE_BUFFER_H_