Parallel and concurrent sweeping.

src/mark-compact.h

 // 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 482 matching lines @@
   SharedFunctionInfo* shared_function_info_candidates_head_;
 
   DISALLOW_COPY_AND_ASSIGN(CodeFlusher);
 };
 
 
 // Defined in isolate.h.
 class ThreadLocalTop;
 
 
+enum SweeperType {

[Michael Starzinger, 2013/01/28 16:30:18]

Move this back into MarkCompactCollector, no longer needed outside.

[Hannes Payer (out of office), 2013/01/30 10:11:27]

Done.

+  CONSERVATIVE,
+  LAZY_CONSERVATIVE,
+  PRECISE
+};
+
+
 // -------------------------------------------------------------------------
 // Mark-Compact collector
 class MarkCompactCollector {
  public:
   // Type of functions to compute forwarding addresses of objects in
   // compacted spaces.  Given an object and its size, return a (non-failure)
   // Object* that will be the object after forwarding.  There is a separate
   // allocation function for each (compactable) space based on the location
   // of the object before compaction.
   typedef MaybeObject* (*AllocationFunction)(Heap* heap,
@@ skipping 64 matching lines @@
   static const uint32_t kMultiFreeEncoding = 1;
 
   static inline bool IsMarked(Object* obj);
 
   inline Heap* heap() const { return heap_; }
 
   CodeFlusher* code_flusher() { return code_flusher_; }
   inline bool is_code_flushing_enabled() const { return code_flusher_ != NULL; }
   void EnableCodeFlushing(bool enable);
 
-  enum SweeperType {
-    CONSERVATIVE,
-    LAZY_CONSERVATIVE,
-    PRECISE
-  };
-
 #ifdef VERIFY_HEAP
   void VerifyMarkbitsAreClean();
   static void VerifyMarkbitsAreClean(PagedSpace* space);
   static void VerifyMarkbitsAreClean(NewSpace* space);
 #endif
 
   // Sweep a single page from the given space conservatively.
   // Return a number of reclaimed bytes.
-  static intptr_t SweepConservatively(PagedSpace* space, Page* p);
+  static intptr_t SweepConservatively(PagedSpace* space,
+                                      FreeList* free_list,
+                                      Page* p);
+
+  static intptr_t Free(PagedSpace* space,
+                       FreeList* free_list,
+                       Address start,
+                       int size);
 
   INLINE(static bool ShouldSkipEvacuationSlotRecording(Object** anchor)) {
     return Page::FromAddress(reinterpret_cast<Address>(anchor))->
         ShouldSkipEvacuationSlotRecording();
   }
 
   INLINE(static bool ShouldSkipEvacuationSlotRecording(Object* host)) {
     return Page::FromAddress(reinterpret_cast<Address>(host))->
         ShouldSkipEvacuationSlotRecording();
   }
@@ skipping 45 matching lines @@
   void InvalidateCode(Code* code);
 
   void ClearMarkbits();
 
   bool abort_incremental_marking() const { return abort_incremental_marking_; }
 
   bool is_compacting() const { return compacting_; }
 
   MarkingParity marking_parity() { return marking_parity_; }
 
+  void SweepInParallel(PagedSpace* space,
+                       SweeperType sweeper_type,

[Michael Starzinger, 2013/01/28 16:30:18]

As discussed offline: Parallel sweeping will always do conservative sweeping. We
need precise sweeping only when the heap needs to be made iterable, and that is
inherently a blocking operation where any lazyness or parallelism with the
mutator makes no sense. So we should just remove the SweeperType from the API.

[Hannes Payer (out of office), 2013/01/30 10:11:27]

Done.

+                       FreeList* private_free_list,
+                       FreeList* free_list);
+
+  void WaitUntilSweepingCompleted();
+
+  intptr_t StealMemoryFromSweeperThreads(PagedSpace* space);
+
+  bool AreSweeperThreadsActivated();
+
  private:
   MarkCompactCollector();
   ~MarkCompactCollector();
 
   bool MarkInvalidatedCode();
   void RemoveDeadInvalidatedCode();
   void ProcessInvalidatedCode(ObjectVisitor* visitor);
 
+  void StartSweeperThreads(SweeperType sweeper_type);
 
 #ifdef DEBUG
   enum CollectorState {
     IDLE,
     PREPARE_GC,
     MARK_LIVE_OBJECTS,
     SWEEP_SPACES,
     ENCODE_FORWARDING_ADDRESSES,
     UPDATE_POINTERS,
     RELOCATE_OBJECTS
@@ skipping 144 matching lines @@
   void EvacuateNewSpace();
 
   void EvacuateLiveObjectsFromPage(Page* p);
 
   void EvacuatePages();
 
   void EvacuateNewSpaceAndCandidates();
 
   void SweepSpace(PagedSpace* space, SweeperType sweeper);
 
+  void PrepareParallelSweeping(PagedSpace* space);
+
 #ifdef DEBUG
   friend class MarkObjectVisitor;
   static void VisitObject(HeapObject* obj);
 
   friend class UnmarkObjectVisitor;
   static void UnmarkObject(HeapObject* obj);
 #endif
 
   Heap* heap_;
   MarkingDeque marking_deque_;
   CodeFlusher* code_flusher_;
   Object* encountered_weak_maps_;
 
   List<Page*> evacuation_candidates_;
   List<Code*> invalidated_code_;
 
   friend class Heap;
 };
 
 
 const char* AllocationSpaceName(AllocationSpace space);
 
 } }  // namespace v8::internal
 
 #endif  // V8_MARK_COMPACT_H_