Wait for sweeper threads only if we have to.

src/spaces.h

Index: src/spaces.h
diff --git a/src/spaces.h b/src/spaces.h
index a940eed5a6c4ae463fe10e173ce7a8321dd230bf..e07f63c711ffdaa5ef5668a8e0a6b396849dd909 100644
--- a/src/spaces.h
+++ b/src/spaces.h
@@ -1905,6 +1905,9 @@ class PagedSpace : public Space {
   bool was_swept_conservatively() { return was_swept_conservatively_; }
   void set_was_swept_conservatively(bool b) { was_swept_conservatively_ = b; }
 
+  bool was_swept_concurrently() { return was_swept_concurrently_; }
+  void set_was_swept_concurrently(bool b) { was_swept_concurrently_ = b; }
+
   // Evacuation candidates are swept by evacuator.  Needs to return a valid
   // result before _and_ after evacuation has finished.
   static bool ShouldBeSweptBySweeperThreads(Page* p) {
@@ -1986,8 +1989,13 @@ class PagedSpace : public Space {
   // Normal allocation information.
   AllocationInfo allocation_info_;
 
+  // Indicates if this space was swept conservatively or precisely resulting in
+  // an non-iterable or iterable heap, respectively.

[Hannes Payer (out of office), 2014/07/02 07:02:53]

Actually, we could just store the sweeper type itself. I will do that.

   bool was_swept_conservatively_;
 
+  // Indicates if this space was swept by concurrent sweeper threads.
+  bool was_swept_concurrently_;
+
   // The number of free bytes which could be reclaimed by advancing the
   // concurrent sweeper threads.  This is only an estimation because concurrent
   // sweeping is done conservatively.