Revert of [heap] Start sweeper tasks after evacuation.

src/heap/mark-compact.h

 // 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.
 
 #ifndef V8_HEAP_MARK_COMPACT_H_
 #define V8_HEAP_MARK_COMPACT_H_
 
 #include <deque>
 
 #include "src/base/bits.h"
@@ skipping 281 matching lines @@
     typedef std::deque<Page*> SweepingList;
     typedef List<Page*> SweptList;
 
     static int RawSweep(Page* p, FreeListRebuildingMode free_list_mode,
                         FreeSpaceTreatmentMode free_space_mode);
 
     explicit Sweeper(Heap* heap)
         : heap_(heap),
           pending_sweeper_tasks_semaphore_(0),
           sweeping_in_progress_(false),
+          late_pages_(false),
           num_sweeping_tasks_(0) {}
 
     bool sweeping_in_progress() { return sweeping_in_progress_; }
+    bool contains_late_pages() { return late_pages_; }
 
     void AddPage(AllocationSpace space, Page* page);
+    void AddLatePage(AllocationSpace space, Page* page);
 
     int ParallelSweepSpace(AllocationSpace identity, int required_freed_bytes,
                            int max_pages = 0);
     int ParallelSweepPage(Page* page, AllocationSpace identity);
 
-    // After calling this function sweeping is considered to be in progress
-    // and the main thread can sweep lazily, but the background sweeper tasks
-    // are not running yet.
     void StartSweeping();
-    void StartSweeperTasks();
+    void StartSweepingHelper(AllocationSpace space_to_start);
     void EnsureCompleted();
     void EnsureNewSpaceCompleted();
-    bool AreSweeperTasksRunning();
-    bool IsSweepingCompleted(AllocationSpace space);
+    bool IsSweepingCompleted();
     void SweepOrWaitUntilSweepingCompleted(Page* page);
 
     void AddSweptPageSafe(PagedSpace* space, Page* page);
     Page* GetSweptPageSafe(PagedSpace* space);
 
    private:
     static const int kAllocationSpaces = LAST_PAGED_SPACE + 1;
 
     template <typename Callback>
     void ForAllSweepingSpaces(Callback callback) {
       for (int i = 0; i < kAllocationSpaces; i++) {
         callback(static_cast<AllocationSpace>(i));
       }
     }
 
     Page* GetSweepingPageSafe(AllocationSpace space);
     void AddSweepingPageSafe(AllocationSpace space, Page* page);
 
     void PrepareToBeSweptPage(AllocationSpace space, Page* page);
 
     Heap* heap_;
     base::Semaphore pending_sweeper_tasks_semaphore_;
     base::Mutex mutex_;
     SweptList swept_list_[kAllocationSpaces];
     SweepingList sweeping_list_[kAllocationSpaces];
     bool sweeping_in_progress_;
+    bool late_pages_;
     base::AtomicNumber<intptr_t> num_sweeping_tasks_;
   };
 
   enum IterationMode {
     kKeepMarking,
     kClearMarkbits,
   };
 
   static void Initialize();
 
@@ skipping 279 matching lines @@
   // We have to remove all encountered weak maps from the list of weak
   // collections when incremental marking is aborted.
   void AbortWeakCollections();
 
   void ClearWeakCells(Object** non_live_map_list,
                       DependentCode** dependent_code_list);
   void AbortWeakCells();
 
   void AbortTransitionArrays();
 
-  // Starts sweeping of spaces by contributing on the main thread and setting
-  // up other pages for sweeping. Does not start sweeper tasks.
-  void StartSweepSpaces();
-  void StartSweepSpace(PagedSpace* space);
+  // -----------------------------------------------------------------------
+  // Phase 2: Sweeping to clear mark bits and free non-live objects for
+  // a non-compacting collection.
+  //
+  //  Before: Live objects are marked and non-live objects are unmarked.
+  //
+  //   After: Live objects are unmarked, non-live regions have been added to
+  //          their space's free list. Active eden semispace is compacted by
+  //          evacuation.
+  //
+
+  // If we are not compacting the heap, we simply sweep the spaces except
+  // for the large object space, clearing mark bits and adding unmarked
+  // regions to each space's free list.
+  void SweepSpaces();
 
   void EvacuateNewSpacePrologue();
 
   void EvacuatePagesInParallel();
 
   // The number of parallel compaction tasks, including the main thread.
   int NumberOfParallelCompactionTasks(int pages, intptr_t live_bytes);
 
   void EvacuateNewSpaceAndCandidates();
 
   void UpdatePointersAfterEvacuation();
 
   // Iterates through all live objects on a page using marking information.
   // Returns whether all objects have successfully been visited.
   template <class Visitor>
   bool VisitLiveObjects(MemoryChunk* page, Visitor* visitor,
                         IterationMode mode);
 
   void RecomputeLiveBytes(MemoryChunk* page);
 
   void ReleaseEvacuationCandidates();
 
+  // Starts sweeping of a space by contributing on the main thread and setting
+  // up other pages for sweeping.
+  void StartSweepSpace(PagedSpace* space);
 
 #ifdef DEBUG
   friend class MarkObjectVisitor;
   static void VisitObject(HeapObject* obj);
 
   friend class UnmarkObjectVisitor;
   static void UnmarkObject(HeapObject* obj);
 #endif
 
   Heap* heap_;
@@ skipping 56 matching lines @@
 
  private:
   MarkCompactCollector* collector_;
 };
 
 V8_EXPORT_PRIVATE const char* AllocationSpaceName(AllocationSpace space);
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_MARK_COMPACT_H_