[Heap] ScavengerCollector use Jobs.

No yielding is necessary since the main thread Join()s.

max concurrency is determined based on either
remaining_memory_chunks_ or global pool size
(copied_list_ + promotion_list_)

Change-Id: Ie30fa86c44d3224b04df5d79569bce126ce7d96b
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2354390
Commit-Queue: Etienne Pierre-Doray <etiennep@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69746}

src/heap/scavenger-inl.h

@@ -38,6 +38,10 @@ bool Scavenger::PromotionList::View::Pop(struct PromotionListEntry* entry) {
   return promotion_list_->Pop(task_id_, entry);
 }
 
+void Scavenger::PromotionList::View::FlushToGlobal() {
+  promotion_list_->FlushToGlobal(task_id_);
+}
+
 bool Scavenger::PromotionList::View::IsGlobalPoolEmpty() {
   return promotion_list_->IsGlobalPoolEmpty();
 }
@@ -78,6 +82,16 @@ bool Scavenger::PromotionList::Pop(int task_id,
   return large_object_promotion_list_.Pop(task_id, entry);
 }
 
+void Scavenger::PromotionList::FlushToGlobal(int task_id) {
+  regular_object_promotion_list_.FlushToGlobal(task_id);
+  large_object_promotion_list_.FlushToGlobal(task_id);
+}
+
+size_t Scavenger::PromotionList::GlobalPoolSize() const {
+  return regular_object_promotion_list_.GlobalPoolSize() +
+         large_object_promotion_list_.GlobalPoolSize();
+}
+
 bool Scavenger::PromotionList::IsGlobalPoolEmpty() {
   return regular_object_promotion_list_.IsGlobalPoolEmpty() &&
          large_object_promotion_list_.IsGlobalPoolEmpty();

src/heap/scavenger.h

@@ -33,38 +33,7 @@ constexpr int kEphemeronTableListSegmentSize = 128;
 using EphemeronTableList =
     Worklist<EphemeronHashTable, kEphemeronTableListSegmentSize>;
 
-class ScavengerCollector {
- public:
-  static const int kMaxScavengerTasks = 8;
-  static const int kMaxWaitTimeMs = 2;
-
-  explicit ScavengerCollector(Heap* heap);
-
-  void CollectGarbage();
-
- private:
-  void MergeSurvivingNewLargeObjects(
-      const SurvivingNewLargeObjectsMap& objects);
-
-  int NumberOfScavengeTasks();
-
-  void ProcessWeakReferences(EphemeronTableList* ephemeron_table_list);
-  void ClearYoungEphemerons(EphemeronTableList* ephemeron_table_list);
-  void ClearOldEphemerons();
-  void HandleSurvivingNewLargeObjects();
-
-  void SweepArrayBufferExtensions();
-
-  void IterateStackAndScavenge(RootScavengeVisitor* root_scavenge_visitor,
-                               Scavenger** scavengers, int num_scavenge_tasks,
-                               int main_thread_id);
-  Isolate* const isolate_;
-  Heap* const heap_;
-  base::Semaphore parallel_scavenge_semaphore_;
-  SurvivingNewLargeObjectsMap surviving_new_large_objects_;
-
-  friend class Scavenger;
-};
+class ScavengerCollector;
 
 class Scavenger {
  public:
@@ -88,6 +57,7 @@ class Scavenger {
       inline bool Pop(struct PromotionListEntry* entry);
       inline bool IsGlobalPoolEmpty();
       inline bool ShouldEagerlyProcessPromotionList();
+      inline void FlushToGlobal();
 
      private:
       PromotionList* promotion_list_;
@@ -102,10 +72,12 @@ class Scavenger {
     inline void PushLargeObject(int task_id, HeapObject object, Map map,
                                 int size);
     inline bool IsEmpty();
+    inline size_t GlobalPoolSize() const;
     inline size_t LocalPushSegmentSize(int task_id);
     inline bool Pop(int task_id, struct PromotionListEntry* entry);
     inline bool IsGlobalPoolEmpty();
     inline bool ShouldEagerlyProcessPromotionList(int task_id);
+    inline void FlushToGlobal(int task_id);
 
    private:
     static const int kRegularObjectPromotionListSegmentSize = 256;
@@ -134,10 +106,11 @@ class Scavenger {
 
   // Processes remaining work (=objects) after single objects have been
   // manually scavenged using ScavengeObject or CheckAndScavengeObject.
-  void Process(OneshotBarrier* barrier = nullptr);
+  void Process(JobDelegate* delegate = nullptr);
 
   // Finalize the Scavenger. Needs to be called from the main thread.
   void Finalize();
+  void Flush();
 
   void AddEphemeronHashTable(EphemeronHashTable table);
 
@@ -276,6 +249,63 @@ class ScavengeVisitor final : public NewSpaceVisitor<ScavengeVisitor> {
   Scavenger* const scavenger_;
 };
 
+class ScavengerCollector {
+ public:
+  static const int kMaxScavengerTasks = 8;
+  static const int kMainThreadId = 0;
+
+  explicit ScavengerCollector(Heap* heap);
+
+  void CollectGarbage();
+
+ private:
+  class JobTask : public v8::JobTask {
+   public:
+    explicit JobTask(ScavengerCollector* outer,
+                     std::vector<std::unique_ptr<Scavenger>>* scavengers,
+                     std::vector<std::pair<bool, MemoryChunk*>> memory_chunks,
+                     Scavenger::CopiedList* copied_list,
+                     Scavenger::PromotionList* promotion_list);
+
+    void Run(JobDelegate* delegate) override;
+    size_t GetMaxConcurrency(size_t worker_count) const override;
+
+   private:
+    void ConcurrentScavengePages(Scavenger* scavenger);
+
+    ScavengerCollector* outer_;
+
+    std::vector<std::unique_ptr<Scavenger>>* scavengers_;
+    std::vector<std::pair<bool, MemoryChunk*>> memory_chunks_;
+    std::atomic<size_t> remaining_memory_chunks_{0};
+
+    Scavenger::CopiedList* copied_list_;
+    Scavenger::PromotionList* promotion_list_;
+  };
+
+  void MergeSurvivingNewLargeObjects(
+      const SurvivingNewLargeObjectsMap& objects);
+
+  int NumberOfScavengeTasks();
+
+  void ProcessWeakReferences(EphemeronTableList* ephemeron_table_list);
+  void ClearYoungEphemerons(EphemeronTableList* ephemeron_table_list);
+  void ClearOldEphemerons();
+  void HandleSurvivingNewLargeObjects();
+
+  void SweepArrayBufferExtensions();
+
+  void IterateStackAndScavenge(
+      RootScavengeVisitor* root_scavenge_visitor,
+      std::vector<std::unique_ptr<Scavenger>>* scavengers, int main_thread_id);
+
+  Isolate* const isolate_;
+  Heap* const heap_;
+  SurvivingNewLargeObjectsMap surviving_new_large_objects_;
+
+  friend class Scavenger;
+};
+
 }  // namespace internal
 }  // namespace v8