[heap] Use callbacks to dispatch store buffer operations.

src/heap/store-buffer.h

 // Copyright 2011 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_STORE_BUFFER_H_
 #define V8_STORE_BUFFER_H_
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/base/platform/platform.h"
@@ skipping 45 matching lines @@
   }
 
   inline Address UnmarkDeletionAddress(Address address) {
     return reinterpret_cast<Address>(reinterpret_cast<intptr_t>(address) &
                                      ~kDeletionTag);
   }
 
   // If we only want to delete a single slot, end should be set to null which
   // will be written into the second field. When processing the store buffer
   // the more efficient Remove method will be called in this case.
-  void DeleteEntry(Address start, Address end = nullptr);
+  void DeleteEntry(Address start, Address end = nullptr) {
+    // Deletions coming from the GC are directly deleted from the remembered
+    // set. Deletions coming from the runtime are added to the store buffer
+    // to allow concurrent processing.
+    deletion_callback(this, start, end);
+  }
+
+  static void DeleteDuringGarbageCollection(StoreBuffer* store_buffer,
+                                            Address start, Address end) {
+    // In GC the store buffer has to be empty at any time.
+    DCHECK(store_buffer->Empty());
+    DCHECK(store_buffer->heap()->gc_state() != Heap::NOT_IN_GC);
+    Page* page = Page::FromAddress(start);
+    if (end) {
+      RememberedSet<OLD_TO_NEW>::RemoveRange(page, start, end,
+                                             SlotSet::PREFREE_EMPTY_BUCKETS);
+    } else {
+      RememberedSet<OLD_TO_NEW>::Remove(page, start);
+    }
+  }
+
+  static void DeleteDuringRuntime(StoreBuffer* store_buffer, Address start,
+                                  Address end) {
+    DCHECK(store_buffer->heap()->gc_state() == Heap::NOT_IN_GC);
+    store_buffer->InsertDeletionIntoStoreBuffer(start, end);
+  }
+
+  void InsertDeletionIntoStoreBuffer(Address start, Address end) {
+    if (top_ + sizeof(Address) * 2 > limit_[current_]) {
+      StoreBufferOverflow(heap_->isolate());
+    }
+    *top_ = MarkDeletionAddress(start);
+    top_++;
+    *top_ = end;
+    top_++;
+  }
+
+  static void InsertDuringGarbageCollection(StoreBuffer* store_buffer,
+                                            Address slot) {
+    DCHECK(store_buffer->heap()->gc_state() != Heap::NOT_IN_GC);
+    RememberedSet<OLD_TO_NEW>::Insert(Page::FromAddress(slot), slot);
+  }
+
+  static void InsertDuringRuntime(StoreBuffer* store_buffer, Address slot) {
+    DCHECK(store_buffer->heap()->gc_state() == Heap::NOT_IN_GC);
+    store_buffer->InsertIntoStoreBuffer(slot);
+  }
+
+  void InsertIntoStoreBuffer(Address slot) {
+    if (top_ + sizeof(Address) > limit_[current_]) {
+      StoreBufferOverflow(heap_->isolate());
+    }
+    *top_ = slot;
+    top_++;
+  }
 
   void InsertEntry(Address slot) {
     // Insertions coming from the GC are directly inserted into the remembered
     // set. Insertions coming from the runtime are added to the store buffer to
     // allow concurrent processing.
-    if (heap_->gc_state() == Heap::NOT_IN_GC) {
-      if (top_ + sizeof(Address) > limit_[current_]) {
-        StoreBufferOverflow(heap_->isolate());
-      }
-      *top_ = slot;
-      top_++;
+    insertion_callback(this, slot);
+  }
+
+  void SetMode(Heap::HeapState state) {
+    if (state == Heap::NOT_IN_GC) {
+      insertion_callback = &InsertDuringRuntime;
+      deletion_callback = &DeleteDuringRuntime;
     } else {
-      // In GC the store buffer has to be empty at any time.
-      DCHECK(Empty());
-      RememberedSet<OLD_TO_NEW>::Insert(Page::FromAddress(slot), slot);
+      insertion_callback = &InsertDuringGarbageCollection;
+      deletion_callback = &DeleteDuringGarbageCollection;
     }
   }
 
   // Used by the concurrent processing thread to transfer entries from the
   // store buffer to the remembered set.
   void ConcurrentlyProcessStoreBuffer();
 
   bool Empty() {
     for (int i = 0; i < kStoreBuffers; i++) {
       if (lazy_top_[i]) {
         return false;
       }
     }
     return top_ == start_[current_];
   }
 
+  Heap* heap() { return heap_; }
+
  private:
   // There are two store buffers. If one store buffer fills up, the main thread
   // publishes the top pointer of the store buffer that needs processing in its
   // global lazy_top_ field. After that it start the concurrent processing
   // thread. The concurrent processing thread uses the pointer in lazy_top_.
   // It will grab the given mutex and transfer its entries to the remembered
   // set. If the concurrent thread does not make progress, the main thread will
   // perform the work.
   // Important: there is an ordering constrained. The store buffer with the
   // older entries has to be processed first.
@@ skipping 28 matching lines @@
   Address* lazy_top_[kStoreBuffers];
   base::Mutex mutex_;
 
   // We only want to have at most one concurrent processing tas running.
   bool task_running_;
 
   // Points to the current buffer in use.
   int current_;
 
   base::VirtualMemory* virtual_memory_;
+
+  // Callbacks are more efficient than reading out the gc state for every
+  // store buffer operation.

[predrag.rudic, 2016/12/23 11:55:17]

There is a problem with this code because it fails to compile on MIPS
architecture for Android. It is found that this is due to bug in compiler.
There is a workaround for this. If only types of deletion_callback and
insertion_callback is replaced with function pointer, code compiles fine.
Is it OK to upload patch that will fix this issue?

[Hannes Payer (out of office), 2017/01/23 13:43:52]

Interestingly, simple function pointers turned out to be slower. We can try your
patch and see what it is doing to performance on the perf bots.

+  std::function<void(StoreBuffer*, Address)> insertion_callback;
+  std::function<void(StoreBuffer*, Address, Address)> deletion_callback;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_STORE_BUFFER_H_