[heap] Ensure consistency between store buffer mode and moving all entries to remembered set.

src/heap/heap.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/heap.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/ast/context-slot-cache.h"
 #include "src/base/bits.h"
@@ skipping 280 matching lines @@
     return MARK_COMPACTOR;
   }
 
   // Default
   *reason = NULL;
   return YoungGenerationCollector();
 }
 
 void Heap::SetGCState(HeapState state) {
   gc_state_ = state;
-  store_buffer_->SetMode(gc_state_);
 }
 
 // TODO(1238405): Combine the infrastructure for --heap-stats and
 // --log-gc to avoid the complicated preprocessor and flag testing.
 void Heap::ReportStatisticsBeforeGC() {
 // Heap::ReportHeapStatistics will also log NewSpace statistics when
 // compiled --log-gc is set.  The following logic is used to avoid
 // double logging.
 #ifdef DEBUG
   if (FLAG_heap_stats || FLAG_log_gc) new_space_->CollectStatistics();
@@ skipping 131 matching lines @@
   ReportStatisticsBeforeGC();
 #endif  // DEBUG
 
   if (new_space_->IsAtMaximumCapacity()) {
     maximum_size_scavenges_++;
   } else {
     maximum_size_scavenges_ = 0;
   }
   CheckNewSpaceExpansionCriteria();
   UpdateNewSpaceAllocationCounter();
-  store_buffer()->MoveAllEntriesToRememberedSet();
 }
 
 size_t Heap::SizeOfObjects() {
   size_t total = 0;
   AllSpaces spaces(this);
   for (Space* space = spaces.next(); space != NULL; space = spaces.next()) {
     total += space->SizeOfObjects();
   }
   return total;
 }
@@ skipping 47 matching lines @@
         static_cast<int>(reinterpret_cast<intptr_t>(local_entry->value));
     DCHECK_GT(value, 0);
 
     if (site->IncrementMementoFoundCount(value)) {
       global_pretenuring_feedback_->LookupOrInsert(site,
                                                    ObjectHash(site->address()));
     }
   }
 }
 
+class Heap::SkipStoreBufferScope {
+ public:
+  explicit SkipStoreBufferScope(StoreBuffer* store_buffer)
+      : store_buffer_(store_buffer) {
+    store_buffer_->MoveAllEntriesToRememberedSet();
+    store_buffer_->SetMode(StoreBuffer::IN_GC);
+  }
+
+  ~SkipStoreBufferScope() {
+    DCHECK(store_buffer_->Empty());
+    store_buffer_->SetMode(StoreBuffer::NOT_IN_GC);
+  }
+
+ private:
+  StoreBuffer* store_buffer_;
+};
 
 class Heap::PretenuringScope {
  public:
   explicit PretenuringScope(Heap* heap) : heap_(heap) {
     heap_->global_pretenuring_feedback_ =
         new base::HashMap(kInitialFeedbackCapacity);
   }
 
   ~PretenuringScope() {
     delete heap_->global_pretenuring_feedback_;
@@ skipping 789 matching lines @@
       CallGCPrologueCallbacks(gc_type, kNoGCCallbackFlags);
     }
   }
 
   EnsureFromSpaceIsCommitted();
 
   int start_new_space_size = static_cast<int>(Heap::new_space()->Size());
 
   {
     Heap::PretenuringScope pretenuring_scope(this);
+    Heap::SkipStoreBufferScope skip_store_buffer_scope(store_buffer_);
 
     switch (collector) {
       case MARK_COMPACTOR:
         UpdateOldGenerationAllocationCounter();
         // Perform mark-sweep with optional compaction.
         MarkCompact();
         old_generation_size_configured_ = true;
         // This should be updated before PostGarbageCollectionProcessing, which
         // can cause another GC. Take into account the objects promoted during
         // GC.
@@ skipping 5213 matching lines @@
 }
 
 
 // static
 int Heap::GetStaticVisitorIdForMap(Map* map) {
   return StaticVisitorBase::GetVisitorId(map);
 }
 
 }  // namespace internal
 }  // namespace v8