[heap] Reland: Take page lock when scavenging old to new references in Scavenger.

src/heap/remembered-set.h

 // Copyright 2016 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_REMEMBERED_SET_H
 #define V8_REMEMBERED_SET_H
 
 #include "src/assembler.h"
 #include "src/heap/heap.h"
 #include "src/heap/slot-set.h"
 #include "src/heap/spaces.h"
 
 namespace v8 {
 namespace internal {
 
+enum RememberedSetIterationMode { SYNCHRONIZED, NON_SYNCHRONIZED };
+
 // TODO(ulan): Investigate performance of de-templatizing this class.
 template <RememberedSetType type>
 class RememberedSet : public AllStatic {
  public:
   // Given a page and a slot in that page, this function adds the slot to the
   // remembered set.
   static void Insert(MemoryChunk* chunk, Address slot_addr) {
     DCHECK(chunk->Contains(slot_addr));
     SlotSet* slot_set = chunk->slot_set<type>();
     if (slot_set == nullptr) {
@@ skipping 65 matching lines @@
           // Clear slots from the beginning of the last page to end_offset.
           slot_set[end_chunk].RemoveRange(0, offset_in_end_chunk, mode);
         }
       }
     }
   }
 
   // Iterates and filters the remembered set with the given callback.
   // The callback should take (Address slot) and return SlotCallbackResult.
   template <typename Callback>
-  static void Iterate(Heap* heap, Callback callback) {
-    IterateMemoryChunks(
-        heap, [callback](MemoryChunk* chunk) { Iterate(chunk, callback); });
+  static void Iterate(Heap* heap, RememberedSetIterationMode mode,
+                      Callback callback) {
+    IterateMemoryChunks(heap, [mode, callback](MemoryChunk* chunk) {
+      if (mode == SYNCHRONIZED) chunk->mutex()->Lock();
+      Iterate(chunk, callback);
+      if (mode == SYNCHRONIZED) chunk->mutex()->Unlock();
+    });
   }
 
   // Iterates over all memory chunks that contains non-empty slot sets.
   // The callback should take (MemoryChunk* chunk) and return void.
   template <typename Callback>
   static void IterateMemoryChunks(Heap* heap, Callback callback) {
     MemoryChunkIterator it(heap);
     MemoryChunk* chunk;
     while ((chunk = it.next()) != nullptr) {
       SlotSet* slots = chunk->slot_set<type>();
@@ skipping 56 matching lines @@
                                                          : KEEP_SLOT;
           },
           TypedSlotSet::PREFREE_EMPTY_CHUNKS);
     }
   }
 
   // Iterates and filters the remembered set with the given callback.
   // The callback should take (SlotType slot_type, SlotAddress slot) and return
   // SlotCallbackResult.
   template <typename Callback>
-  static void IterateTyped(Heap* heap, Callback callback) {
-    IterateMemoryChunks(heap, [callback](MemoryChunk* chunk) {
+  static void IterateTyped(Heap* heap, RememberedSetIterationMode mode,
+                           Callback callback) {
+    IterateMemoryChunks(heap, [mode, callback](MemoryChunk* chunk) {
+      if (mode == SYNCHRONIZED) chunk->mutex()->Lock();
       IterateTyped(chunk, callback);
+      if (mode == SYNCHRONIZED) chunk->mutex()->Unlock();
     });
   }
 
   // Iterates and filters typed old to old pointers in the given memory chunk
   // with the given callback. The callback should take (SlotType slot_type,
   // Address slot_addr) and return SlotCallbackResult.
   template <typename Callback>
   static void IterateTyped(MemoryChunk* chunk, Callback callback) {
     TypedSlotSet* slots = chunk->typed_slot_set<type>();
     if (slots != nullptr) {
@@ skipping 154 matching lines @@
     return DEBUG_TARGET_SLOT;
   }
   UNREACHABLE();
   return CLEARED_SLOT;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_REMEMBERED_SET_H