Mark WeakMaps concurrently

Mark JSWeakCollections and EphemeronHashTables concurrently to
the application to reduce pause times.

Bug: chromium:844008
Change-Id: I0a8fe592e651b368c5c12846d02d55bbf4058ff2
Reviewed-on: https://chromium-review.googlesource.com/1095035Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Commit-Queue: Dominik Inführ <dinfuehr@google.com>
Cr-Commit-Position: refs/heads/master@{#53641}

src/heap/concurrent-marking.cc

@@ -19,6 +19,7 @@
 #include "src/heap/objects-visiting.h"
 #include "src/heap/worklist.h"
 #include "src/isolate.h"
+#include "src/objects/hash-table-inl.h"
 #include "src/utils-inl.h"
 #include "src/utils.h"
 #include "src/v8.h"
@@ -352,14 +353,35 @@ class ConcurrentMarkingVisitor final
   }
 
   int VisitJSWeakCollection(Map* map, JSWeakCollection* object) {
-    // TODO(ulan): implement iteration of strong fields.
-    bailout_.Push(object);
-    return 0;
+    return VisitJSObjectSubclass(map, object);
   }
 
-  int VisitEphemeronHashTable(Map* map, EphemeronHashTable* object) {
-    bailout_.Push(object);
-    return 0;
+  int VisitEphemeronHashTable(Map* map, EphemeronHashTable* table) {
+    if (!ShouldVisit(table)) return 0;
+    weak_objects_->ephemeron_hash_tables.Push(task_id_, table);
+
+    for (int i = 0; i < table->Capacity(); i++) {
+      HeapObject* key = HeapObject::cast(table->KeyAt(i));
+
+      Object** key_slot =
+          table->RawFieldOfElementAt(EphemeronHashTable::EntryToIndex(i));
+      Object** value_slot =
+          table->RawFieldOfElementAt(EphemeronHashTable::EntryToValueIndex(i));
+
+      MarkCompactCollector::RecordSlot(table, key_slot, *key_slot);
+
+      if (marking_state_.IsBlackOrGrey(key)) {
+        VisitPointer(table, value_slot);
+      } else {
+        Object* value = *value_slot;
+
+        if (value->IsHeapObject()) {
+          MarkCompactCollector::RecordSlot(table, value_slot, value);
+        }
+      }
+    }
+
+    return table->SizeFromMap(map);
   }
 
   void MarkObject(HeapObject* object) {
@@ -580,6 +602,7 @@ void ConcurrentMarking::Run(int task_id, TaskState* task_state) {
 
     weak_objects_->weak_cells.FlushToGlobal(task_id);
     weak_objects_->transition_arrays.FlushToGlobal(task_id);
+    weak_objects_->ephemeron_hash_tables.FlushToGlobal(task_id);
     weak_objects_->weak_references.FlushToGlobal(task_id);
     base::AsAtomicWord::Relaxed_Store<size_t>(&task_state->marked_bytes, 0);
     total_marked_bytes_ += marked_bytes;

src/heap/mark-compact.cc

@@ -1859,9 +1859,6 @@ void MarkCompactCollector::ProcessWeakCollections() {
     for (int i = 0; i < table->Capacity(); i++) {
       HeapObject* heap_object = HeapObject::cast(table->KeyAt(i));
       if (non_atomic_marking_state()->IsBlackOrGrey(heap_object)) {
-        Object** key_slot =
-            table->RawFieldOfElementAt(EphemeronHashTable::EntryToIndex(i));
-        RecordSlot(table, key_slot, *key_slot);
         Object** value_slot = table->RawFieldOfElementAt(
             EphemeronHashTable::EntryToValueIndex(i));
         if (V8_UNLIKELY(FLAG_track_retaining_path) &&
@@ -1960,6 +1957,7 @@ void MarkCompactCollector::AbortWeakObjects() {
   weak_objects_.transition_arrays.Clear();
   weak_objects_.weak_references.Clear();
   weak_objects_.weak_objects_in_code.Clear();
+  weak_objects_.ephemeron_hash_tables.Clear();
 }
 
 void MarkCompactCollector::RecordRelocSlot(Code* host, RelocInfo* rinfo,