[heap] Base number of compaction tasks on live memory and compaction speed.

src/heap/mark-compact.cc

 // Copyright 2012 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.
 
 #include "src/heap/mark-compact.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/base/sys-info.h"
 #include "src/code-stubs.h"
@@ skipping 3292 matching lines @@
     *cell = 0;
   }
   p->ResetLiveBytes();
   return true;
 }
 
 
 int MarkCompactCollector::NumberOfParallelCompactionTasks() {
   if (!FLAG_parallel_compaction) return 1;
   // We cap the number of parallel compaction tasks by
+  // - a hard limit
   // - (#cores - 1)
-  // - a value depending on the live memory in evacuation candidates
-  // - a hard limit
-  //
-  // TODO(mlippautz): Instead of basing the limit on live memory, we could also
-  //   compute the number from the time it takes to evacuate memory and a given
-  //   desired time in which compaction should be finished.
-  const int kLiveMemoryPerCompactionTask = 2 * Page::kPageSize;
+  // - a target compaction time, considering compaction speed and live memory
+  const double kTargetCompactionTimeInMs = 2;

[Hannes Payer (out of office), 2015/11/03 04:08:17]

Let's aim for 1 ms. Keep the constant, it has at least a documentation purpose.

[Michael Lippautz, 2015/11/03 20:57:42]

Done.

I also restructured the bottom part (return statement) and the order of caps in
the comments now matches the code.

   const int kMaxCompactionTasks = 8;
-  int live_bytes = 0;
+
+  intptr_t compaction_speed =
+      heap()->tracer()->CompactionSpeedInBytesPerMillisecond();
+  if (compaction_speed == 0) return 1;
+
+  intptr_t live_bytes = 0;
   for (Page* page : evacuation_candidates_) {
     live_bytes += page->LiveBytes();
   }
-  return Min(kMaxCompactionTasks,
-             Min(1 + live_bytes / kLiveMemoryPerCompactionTask,
-                 Max(1, base::SysInfo::NumberOfProcessors() - 1)));
+
+  return Min(
+      kMaxCompactionTasks,
+      Min(1 + static_cast<int>(static_cast<double>(live_bytes) /
+                               compaction_speed / kTargetCompactionTimeInMs),
+          Max(1, base::SysInfo::NumberOfProcessors() - 1)));
 }
 
 
 void MarkCompactCollector::EvacuatePagesInParallel() {
   const int num_pages = evacuation_candidates_.length();
   if (num_pages == 0) return;
 
+  // Used for trace summary.
+  intptr_t live_bytes = 0;
+  intptr_t compaction_speed = 0;
+  if (FLAG_trace_fragmentation) {
+    for (Page* page : evacuation_candidates_) {
+      live_bytes += page->LiveBytes();
+    }
+    compaction_speed = heap()->tracer()->CompactionSpeedInBytesPerMillisecond();
+  }
   const int num_tasks = NumberOfParallelCompactionTasks();
 
+
   // Set up compaction spaces.
   CompactionSpaceCollection** compaction_spaces_for_tasks =
       new CompactionSpaceCollection*[num_tasks];
   for (int i = 0; i < num_tasks; i++) {
     compaction_spaces_for_tasks[i] = new CompactionSpaceCollection(heap());
   }
 
   heap()->old_space()->DivideUponCompactionSpaces(compaction_spaces_for_tasks,
                                                   num_tasks);
   heap()->code_space()->DivideUponCompactionSpaces(compaction_spaces_for_tasks,
                                                    num_tasks);
 
   compaction_in_progress_ = true;
   // Kick off parallel tasks.
   for (int i = 1; i < num_tasks; i++) {
     concurrent_compaction_tasks_active_++;
     V8::GetCurrentPlatform()->CallOnBackgroundThread(
         new CompactionTask(heap(), compaction_spaces_for_tasks[i]),
         v8::Platform::kShortRunningTask);
   }
 
   // Contribute in main thread. Counter and signal are in principal not needed.
   EvacuatePages(compaction_spaces_for_tasks[0], &migration_slots_buffer_);
 
   WaitUntilCompactionCompleted();
 
+  double compaction_duration = 0.0;
+  intptr_t compacted_memory = 0;
   // Merge back memory (compacted and unused) from compaction spaces.
   for (int i = 0; i < num_tasks; i++) {
     heap()->old_space()->MergeCompactionSpace(
         compaction_spaces_for_tasks[i]->Get(OLD_SPACE));
     heap()->code_space()->MergeCompactionSpace(
         compaction_spaces_for_tasks[i]->Get(CODE_SPACE));
+    compacted_memory += compaction_spaces_for_tasks[i]->bytes_compacted();
+    compaction_duration += compaction_spaces_for_tasks[i]->duration();
     delete compaction_spaces_for_tasks[i];
   }
   delete[] compaction_spaces_for_tasks;
+  heap()->tracer()->AddCompactionEvent(compaction_duration, compacted_memory);
 
   // Finalize sequentially.
   int abandoned_pages = 0;
   for (int i = 0; i < num_pages; i++) {
     Page* p = evacuation_candidates_[i];
     switch (p->parallel_compaction_state().Value()) {
       case MemoryChunk::ParallelCompactingState::kCompactingAborted:
         // We have partially compacted the page, i.e., some objects may have
         // moved, others are still in place.
         // We need to:
@@ skipping 20 matching lines @@
         break;
       default:
         // We should not observe kCompactingInProgress, or kCompactingDone.
         UNREACHABLE();
     }
     p->parallel_compaction_state().SetValue(MemoryChunk::kCompactingDone);
   }
   if (FLAG_trace_fragmentation) {
     PrintIsolate(isolate(),
                  "%8.0f ms: compaction: parallel=%d pages=%d aborted=%d "
-                 "tasks=%d cores=%d\n",
+                 "tasks=%d cores=%d live_bytes=%" V8_PTR_PREFIX
+                 "d compaction_speed=%" V8_PTR_PREFIX "d\n",
                  isolate()->time_millis_since_init(), FLAG_parallel_compaction,
                  num_pages, abandoned_pages, num_tasks,
-                 base::SysInfo::NumberOfProcessors());
+                 base::SysInfo::NumberOfProcessors(), live_bytes,
+                 compaction_speed);
   }
 }
 
 
 void MarkCompactCollector::WaitUntilCompactionCompleted() {
   while (concurrent_compaction_tasks_active_ > 0) {
     pending_compaction_tasks_semaphore_.Wait();
     concurrent_compaction_tasks_active_--;
   }
   compaction_in_progress_ = false;
 }
 
 
 void MarkCompactCollector::EvacuatePages(
     CompactionSpaceCollection* compaction_spaces,
     SlotsBuffer** evacuation_slots_buffer) {
   for (int i = 0; i < evacuation_candidates_.length(); i++) {
     Page* p = evacuation_candidates_[i];
     DCHECK(p->IsEvacuationCandidate() ||
            p->IsFlagSet(Page::RESCAN_ON_EVACUATION));
     DCHECK(static_cast<int>(p->parallel_sweeping_state().Value()) ==
            MemoryChunk::kSweepingDone);
     if (p->parallel_compaction_state().TrySetValue(
             MemoryChunk::kCompactingDone, MemoryChunk::kCompactingInProgress)) {
       if (p->IsEvacuationCandidate()) {
         DCHECK_EQ(p->parallel_compaction_state().Value(),
                   MemoryChunk::kCompactingInProgress);
+        double start = heap_->MonotonicallyIncreasingTimeInMs();
+        intptr_t live_bytes = p->LiveBytes();

[Hannes Payer (out of office), 2015/11/03 04:08:17]

Let's move the time measuring into EvacuateLiveObjectsFromPage.

[Michael Lippautz, 2015/11/03 20:57:42]

Done.

         if (EvacuateLiveObjectsFromPage(
                 p, compaction_spaces->Get(p->owner()->identity()),
                 evacuation_slots_buffer)) {
           p->parallel_compaction_state().SetValue(
               MemoryChunk::kCompactingFinalize);
+          compaction_spaces->ReportCompactionProgress(
+              heap_->MonotonicallyIncreasingTimeInMs() - start, live_bytes);
         } else {
           p->parallel_compaction_state().SetValue(
               MemoryChunk::kCompactingAborted);
         }
       } else {
         // There could be popular pages in the list of evacuation candidates
         // which we do compact.
         p->parallel_compaction_state().SetValue(MemoryChunk::kCompactingDone);
       }
     }
@@ skipping 1141 matching lines @@
     MarkBit mark_bit = Marking::MarkBitFrom(host);
     if (Marking::IsBlack(mark_bit)) {
       RelocInfo rinfo(pc, RelocInfo::CODE_TARGET, 0, host);
       RecordRelocSlot(&rinfo, target);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8