Revert "[Heap] ScavengerCollector use Jobs."

This reverts commit 9e8c54f8.

Reason for revert: Data races (https://ci.chromium.org/p/v8/builders/ci/V8%20Linux64%20TSAN/33100)

Original change's description:
> [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}

TBR=ulan@chromium.org,etiennep@chromium.org

Change-Id: I206397c6086cf18d5e08cf615bdaaf0f34c6d36b
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2398852Reviewed-by: Shu-yu Guo <syg@chromium.org>
Commit-Queue: Shu-yu Guo <syg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69748}

src/heap/scavenger-inl.h

@@ -38,10 +38,6 @@ 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();
 }
@@ -82,16 +78,6 @@ 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,7 +33,38 @@ constexpr int kEphemeronTableListSegmentSize = 128;
 using EphemeronTableList =
     Worklist<EphemeronHashTable, kEphemeronTableListSegmentSize>;
 
-class ScavengerCollector;
+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 Scavenger {
  public:
@@ -57,7 +88,6 @@ class Scavenger {
       inline bool Pop(struct PromotionListEntry* entry);
       inline bool IsGlobalPoolEmpty();
       inline bool ShouldEagerlyProcessPromotionList();
-      inline void FlushToGlobal();
 
      private:
       PromotionList* promotion_list_;
@@ -72,12 +102,10 @@ 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;
@@ -106,11 +134,10 @@ class Scavenger {
 
   // Processes remaining work (=objects) after single objects have been
   // manually scavenged using ScavengeObject or CheckAndScavengeObject.
-  void Process(JobDelegate* delegate = nullptr);
+  void Process(OneshotBarrier* barrier = nullptr);
 
   // Finalize the Scavenger. Needs to be called from the main thread.
   void Finalize();
-  void Flush();
 
   void AddEphemeronHashTable(EphemeronHashTable table);
 
@@ -249,63 +276,6 @@ 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