heap: Prepare concurrent marking for new jobs api

The concurrent marking tasks used to get an ids as an
argument. With the new jobs api we can no longer pass
the id that way.
This CL updates to tasks to get an id from a collection
of available ids. This way all tasks only need to get a
pointer to the ThreadState (so tasks don't get unique
arguments anymore).

Bug: 986235
Change-Id: Ibd7146840c74297dc4531a1b4c6c1475c647464d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1884850
Commit-Queue: Omer Katz <omerkatz@chromium.org>
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Anton Bikineev <bikineev@chromium.org>
Cr-Commit-Position: refs/heads/master@{#712553}

third_party/blink/renderer/platform/heap/thread_state.cc

@@ -729,6 +729,7 @@ void ThreadState::AtomicPauseMarkPrologue(BlinkGC::StackState stack_state,
       // Stop concurrent markers
       marker_scheduler_->CancelAndWait();
       active_markers_ = 0;
+      available_concurrent_marking_ids_.clear();
     }
 #if DCHECK_IS_ON()
     MarkingWorklist* worklist = Heap().GetMarkingWorklist();
@@ -1208,7 +1209,7 @@ bool ThreadState::ConcurrentMarkingStep() {
     ScheduleConcurrentMarking();
     return false;
   }
-  base::AutoLock lock(active_concurrent_markers_lock_);
+  base::AutoLock lock(concurrent_marker_bootstrapping_lock_);
   return active_markers_ == 0;
 }
 
@@ -1691,7 +1692,7 @@ void ThreadState::EnableCompactionForNextGCForTesting() {
 }
 
 void ThreadState::ScheduleConcurrentMarking() {
-  base::AutoLock lock(active_concurrent_markers_lock_);
+  base::AutoLock lock(concurrent_marker_bootstrapping_lock_);
 
   if (active_markers_ > 0) {
     // Concurrent markers are already running, should not run them again
@@ -1713,20 +1714,27 @@ void ThreadState::ScheduleConcurrentMarking() {
   active_markers_ = kNumberOfConcurrentMarkingTasks;
 
   for (int i = 0; i < kNumberOfConcurrentMarkingTasks; ++i) {
-    marker_scheduler_->ScheduleTask(
-        WTF::CrossThreadBindOnce(&ThreadState::PerformConcurrentMark,
-                                 WTF::CrossThreadUnretained(this), i));
+    available_concurrent_marking_ids_.push_back(
+        WorklistTaskId::ConcurrentThreadBase + i);
+    marker_scheduler_->ScheduleTask(WTF::CrossThreadBindOnce(
+        &ThreadState::PerformConcurrentMark, WTF::CrossThreadUnretained(this)));
   }
 }
 
-void ThreadState::PerformConcurrentMark(int concurrent_marker_id) {
+void ThreadState::PerformConcurrentMark() {
   VLOG(2) << "[state:" << this << "] [threadid:" << CurrentThread() << "] "
           << "ConcurrentMark";
   ThreadHeapStatsCollector::EnabledConcurrentScope stats_scope(
       Heap().stats_collector(), ThreadHeapStatsCollector::kConcurrentMark);
 
-  const int task_id =
-      WorklistTaskId::ConcurrentThreadBase + concurrent_marker_id;
+  int task_id;
+  {
+    base::AutoLock lock(concurrent_marker_bootstrapping_lock_);
+    DCHECK(!available_concurrent_marking_ids_.IsEmpty());
+    task_id = available_concurrent_marking_ids_.back();
+    available_concurrent_marking_ids_.pop_back();
+  }
+
   std::unique_ptr<ConcurrentMarkingVisitor> concurrent_visitor =
       IsUnifiedGCMarkingInProgress()
           ? std::make_unique<ConcurrentUnifiedHeapMarkingVisitor>(
@@ -1742,10 +1750,11 @@ void ThreadState::PerformConcurrentMark(int concurrent_marker_id) {
 
   concurrent_visitor->FlushWorklists();
   {
-    base::AutoLock lock(active_concurrent_markers_lock_);
+    base::AutoLock lock(concurrent_marker_bootstrapping_lock_);
     // When marking is done, flush visitor worklists and decrement number of
     // active markers so we know how many markers are left
     concurrently_marked_bytes_ += concurrent_visitor->marked_bytes();
+    available_concurrent_marking_ids_.push_back(task_id);
     if (finished) {
       --active_markers_;
       return;
@@ -1754,8 +1763,7 @@ void ThreadState::PerformConcurrentMark(int concurrent_marker_id) {
 
   // Reschedule this marker
   marker_scheduler_->ScheduleTask(WTF::CrossThreadBindOnce(
-      &ThreadState::PerformConcurrentMark, WTF::CrossThreadUnretained(this),
-      concurrent_marker_id));
+      &ThreadState::PerformConcurrentMark, WTF::CrossThreadUnretained(this)));
 }
 
 }  // namespace blink

third_party/blink/renderer/platform/heap/thread_state.h

@@ -48,6 +48,7 @@
 #include "third_party/blink/renderer/platform/wtf/thread_specific.h"
 #include "third_party/blink/renderer/platform/wtf/threading.h"
 #include "third_party/blink/renderer/platform/wtf/threading_primitives.h"
+#include "third_party/blink/renderer/platform/wtf/vector.h"
 
 namespace v8 {
 class EmbedderGraph;
@@ -301,7 +302,7 @@ class PLATFORM_EXPORT ThreadState final {
   // terminated and the worklist is empty)
   bool ConcurrentMarkingStep();
   void ScheduleConcurrentMarking();
-  void PerformConcurrentMark(int);
+  void PerformConcurrentMark();
 
   void CompleteSweep();
   void NotifySweepDone();
@@ -594,8 +595,9 @@ class PLATFORM_EXPORT ThreadState final {
   std::unique_ptr<IncrementalMarkingScheduler> incremental_marking_scheduler_;
 
   std::unique_ptr<CancelableTaskScheduler> marker_scheduler_;
+  Vector<int> available_concurrent_marking_ids_;
   uint8_t active_markers_ = 0;
-  base::Lock active_concurrent_markers_lock_;
+  base::Lock concurrent_marker_bootstrapping_lock_;
   size_t concurrently_marked_bytes_ = 0;
 
   std::unique_ptr<CancelableTaskScheduler> sweeper_scheduler_;