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

src/heap/spaces.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_HEAP_SPACES_H_
 #define V8_HEAP_SPACES_H_
 
 #include <list>
 #include <memory>
 #include <unordered_set>
@@ skipping 326 matching lines @@
       + kPointerSize      // Address area_end_
       + 2 * kPointerSize  // base::VirtualMemory reservation_
       + kPointerSize      // Address owner_
       + kPointerSize      // Heap* heap_
       + kIntptrSize       // intptr_t progress_bar_
       + kIntptrSize       // intptr_t live_byte_count_
       + kPointerSize * NUMBER_OF_REMEMBERED_SET_TYPES  // SlotSet* array
       + kPointerSize * NUMBER_OF_REMEMBERED_SET_TYPES  // TypedSlotSet* array
       + kPointerSize                                   // SkipList* skip_list_
       + kPointerSize    // AtomicValue high_water_mark_
-      + kPointerSize    // base::Mutex* mutex_
+      + kPointerSize    // base::RecursiveMutex* mutex_
       + kPointerSize    // base::AtomicWord concurrent_sweeping_
       + 2 * kSizetSize  // AtomicNumber free-list statistics
       + kPointerSize    // AtomicValue next_chunk_
       + kPointerSize    // AtomicValue prev_chunk_
       + FreeListCategory::kSize * kNumberOfCategories
       // FreeListCategory categories_[kNumberOfCategories]
       + kPointerSize   // LocalArrayBufferTracker* local_tracker_
       + kIntptrSize    // intptr_t young_generation_live_byte_count_
       + kPointerSize;  // Bitmap* young_generation_bitmap_
 
@@ skipping 39 matching lines @@
     } while ((new_mark > old_mark) &&
              !chunk->high_water_mark_.TrySetValue(old_mark, new_mark));
   }
 
   static bool IsValid(MemoryChunk* chunk) { return chunk != nullptr; }
 
   Address address() const {
     return reinterpret_cast<Address>(const_cast<MemoryChunk*>(this));
   }
 
-  base::Mutex* mutex() { return mutex_; }
+  base::RecursiveMutex* mutex() { return mutex_; }
 
   bool Contains(Address addr) {
     return addr >= area_start() && addr < area_end();
   }
 
   // Checks whether |addr| can be a limit of addresses in this page. It's a
   // limit if it's in the page, or if it's just after the last byte of the page.
   bool ContainsLimit(Address addr) {
     return addr >= area_start() && addr <= area_end();
   }
@@ skipping 188 matching lines @@
   base::AtomicValue<SlotSet*> slot_set_[NUMBER_OF_REMEMBERED_SET_TYPES];
   base::AtomicValue<TypedSlotSet*>
       typed_slot_set_[NUMBER_OF_REMEMBERED_SET_TYPES];
 
   SkipList* skip_list_;
 
   // Assuming the initial allocation on a page is sequential,
   // count highest number of bytes ever allocated on the page.
   base::AtomicValue<intptr_t> high_water_mark_;
 
-  base::Mutex* mutex_;
+  base::RecursiveMutex* mutex_;
 
   base::AtomicValue<ConcurrentSweepingState> concurrent_sweeping_;
 
   // PagedSpace free-list statistics.
   base::AtomicNumber<intptr_t> available_in_free_list_;
   base::AtomicNumber<intptr_t> wasted_memory_;
 
   // next_chunk_ holds a pointer of type MemoryChunk
   base::AtomicValue<MemoryChunk*> next_chunk_;
   // prev_chunk_ holds a pointer of type MemoryChunk
@@ skipping 2324 matching lines @@
   PageIterator old_iterator_;
   PageIterator code_iterator_;
   PageIterator map_iterator_;
   LargePageIterator lo_iterator_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_SPACES_H_