Parallel and concurrent sweeping.

src/heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 545 matching lines @@
 void Heap::CollectAllGarbage(int flags, const char* gc_reason) {
   // Since we are ignoring the return value, the exact choice of space does
   // not matter, so long as we do not specify NEW_SPACE, which would not
   // cause a full GC.
   mark_compact_collector_.SetFlags(flags);
   CollectGarbage(OLD_POINTER_SPACE, gc_reason);
   mark_compact_collector_.SetFlags(kNoGCFlags);
 }
 
 
+void Heap::StartParallelSweeping(SweeperType sweeper_type) {
+  SweeperThread::set_sweeping_pending(true);
+  for (int i = 0; i < FLAG_sweeper_threads; i++) {
+    isolate()->sweeper_threads()[i]->StartSweeping(sweeper_type);
+  }
+}
+
+
+void Heap::WaitUntilParallelSweepingCompleted() {
+  for (int i = 0; i < FLAG_sweeper_threads; i++) {
+    isolate()->sweeper_threads()[i]->WaitForSweeperThread();
+  }
+  SweeperThread::set_sweeping_pending(false);
+  FinalizeParallelSweeping();
+}
+
+
+void Heap::StealMemoryFromSweeperThreads(PagedSpace* space) {
+  for (int i = 0; i < FLAG_sweeper_threads; i++) {
+    isolate()->sweeper_threads()[i]->StealMemory(space);
+  }
+}
+
+
+void Heap::FinalizeParallelSweeping() {
+  StealMemoryFromSweeperThreads(paged_space(OLD_DATA_SPACE));
+  StealMemoryFromSweeperThreads(paged_space(OLD_POINTER_SPACE));
+  FreeQueuedChunks();
+}
+
+
+bool Heap::IsConcurrentSweepingPending() {
+  return SweeperThread::sweeping_pending();
+}
+
+
+bool Heap::IsConcurrentSweepingActivated() {
+  return isolate()->sweeper_threads() != NULL &&
+         FLAG_concurrent_sweeping;
+}
+
+
+bool Heap::AreSweepingThreadsActivated() {
+  return isolate()->sweeper_threads() != NULL &&
+         (FLAG_concurrent_sweeping || FLAG_parallel_sweeping);
+}
+
+
 void Heap::CollectAllAvailableGarbage(const char* gc_reason) {
   // Since we are ignoring the return value, the exact choice of space does
   // not matter, so long as we do not specify NEW_SPACE, which would not
   // cause a full GC.
   // Major GC would invoke weak handle callbacks on weakly reachable
   // handles, but won't collect weakly reachable objects until next
   // major GC.  Therefore if we collect aggressively and weak handle callback
   // has been invoked, we rerun major GC to release objects which become
   // garbage.
   // Note: as weak callbacks can execute arbitrary code, we cannot
@@ skipping 690 matching lines @@
 
   // Used for updating survived_since_last_expansion_ at function end.
   intptr_t survived_watermark = PromotedSpaceSizeOfObjects();
 
   CheckNewSpaceExpansionCriteria();
 
   SelectScavengingVisitorsTable();
 
   incremental_marking()->PrepareForScavenge();
 
-  AdvanceSweepers(static_cast<int>(new_space_.Size()));
+  if (AreSweepingThreadsActivated()) {
+    StealMemoryFromSweeperThreads(paged_space(OLD_DATA_SPACE));
+    StealMemoryFromSweeperThreads(paged_space(OLD_POINTER_SPACE));
+  } else {
+    AdvanceSweepers(static_cast<int>(new_space_.Size()));
+  }
 
   // Flip the semispaces.  After flipping, to space is empty, from space has
   // live objects.
   new_space_.Flip();
   new_space_.ResetAllocationInfo();
 
   // We need to sweep newly copied objects which can be either in the
   // to space or promoted to the old generation.  For to-space
   // objects, we treat the bottom of the to space as a queue.  Newly
   // copied and unswept objects lie between a 'front' mark and the
@@ skipping 6069 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   memcpy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   memcpy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 
 } }  // namespace v8::internal