[heap] Use PageParallelJob for parallel evacuation

src/heap/page-parallel-job.h

 // Copyright 2016 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_PAGE_PARALLEL_JOB_
 #define V8_HEAP_PAGE_PARALLEL_JOB_
 
 #include "src/allocation.h"
 #include "src/cancelable-task.h"
 #include "src/utils.h"
@@ skipping 39 matching lines @@
   }
 
   void AddPage(MemoryChunk* chunk, typename JobTraits::PerPageData data) {
     Item* item = new Item(chunk, data, items_);
     items_ = item;
     ++num_items_;
   }
 
   int NumberOfPages() { return num_items_; }
 
-  // Runs the given number of tasks in parallel and processes the previosly
+  // Returns the number of tasks that were spawned when running the job.
+  int NumberOfTasks() { return num_tasks_; }
+
+  // Runs the given number of tasks in parallel and processes the previously
   // added pages. This function blocks until all tasks finish.
   // The callback takes the index of a task and returns data for that task.
   template <typename Callback>
   void Run(int num_tasks, Callback per_task_data_callback) {
     if (num_items_ == 0) return;
     DCHECK_GE(num_tasks, 1);
     uint32_t task_ids[kMaxNumberOfTasks];
     const int max_num_tasks = Min(
         kMaxNumberOfTasks,
         static_cast<int>(
             V8::GetCurrentPlatform()->NumberOfAvailableBackgroundThreads()));
-    num_tasks = Max(1, Min(num_tasks, max_num_tasks));
-    int items_per_task = (num_items_ + num_tasks - 1) / num_tasks;
+    num_tasks_ = Max(1, Min(num_tasks, max_num_tasks));
+    int items_per_task = (num_items_ + num_tasks_ - 1) / num_tasks_;
     int start_index = 0;
     Task* main_task = nullptr;
-    for (int i = 0; i < num_tasks; i++, start_index += items_per_task) {
+    for (int i = 0; i < num_tasks_; i++, start_index += items_per_task) {
       if (start_index >= num_items_) {
         start_index -= num_items_;
       }
       Task* task = new Task(heap_, items_, num_items_, start_index,
                             &pending_tasks_, per_task_data_callback(i));
       task_ids[i] = task->id();
       if (i > 0) {
         V8::GetCurrentPlatform()->CallOnBackgroundThread(
             task, v8::Platform::kShortRunningTask);
       } else {
         main_task = task;
       }
     }
     // Contribute on main thread.
     main_task->Run();
     delete main_task;
     // Wait for background tasks.
-    for (int i = 0; i < num_tasks; i++) {
+    for (int i = 0; i < num_tasks_; i++) {
       if (!cancelable_task_manager_->TryAbort(task_ids[i])) {
         pending_tasks_.Wait();
       }
     }
     if (JobTraits::NeedSequentialFinalization) {
       Item* item = items_;
       while (item != nullptr) {
         bool success = (item->state.Value() == kFinished);
         JobTraits::FinalizePageSequentially(heap_, item->chunk, success,
                                             item->data);
@@ skipping 60 matching lines @@
     int start_index_;
     base::Semaphore* on_finish_;
     typename JobTraits::PerTaskData data_;
     DISALLOW_COPY_AND_ASSIGN(Task);
   };
 
   Heap* heap_;
   CancelableTaskManager* cancelable_task_manager_;
   Item* items_;
   int num_items_;
+  int num_tasks_;
   base::Semaphore pending_tasks_;
   DISALLOW_COPY_AND_ASSIGN(PageParallelJob);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_PAGE_PARALLEL_JOB_