[heap] Fine-grained JSArrayBuffer tracking

src/heap/array-buffer-tracker.h

Index: src/heap/array-buffer-tracker.h
diff --git a/src/heap/array-buffer-tracker.h b/src/heap/array-buffer-tracker.h
index 6130003d15263fff94d56070d44a4713858ab9da..95723e0c22e766f5fab18a0b915b6bfa062cf5c4 100644
--- a/src/heap/array-buffer-tracker.h
+++ b/src/heap/array-buffer-tracker.h
@@ -17,59 +17,91 @@ namespace internal {
 class Heap;
 class JSArrayBuffer;
 
+class LocalArrayBufferTracker {
+ public:
+  typedef std::pair<void*, size_t> Value;
+  typedef JSArrayBuffer* Key;
+
+  enum CallbackResult { kKeepEntry, kRemoveEntry };
+
+  explicit LocalArrayBufferTracker(Heap* heap) : heap_(heap) {}
+  ~LocalArrayBufferTracker();
+
+  void Add(Key key, const Value& value);
+  void AddLive(Key key, const Value& value);
+  Value Remove(Key key);
+  void MarkLive(Key key);
+  bool IsEmpty();
+
+  // Frees up any dead backing stores of not yet discovered array buffers and
+  // resets the tracking set, i.e., not yet discovered <- currently live. Note
+  // that this method should be called at most once during a GC cycle as marking
+  // and evacuation properly marks live array buffers. Also, the call can be
+  // omitted, resulting in floating garbage.
+  void FreeDeadAndReset();
+
+  // Callback should be of type:
+  //   CallbackResult fn(Key);
+  template <typename Callback>
+  void IterateNotYetDiscoveredEntries(Callback callback) {
+    for (TrackingMap::iterator it = not_yet_discovered_.begin();
+         it != not_yet_discovered_.end();) {
+      if (callback(it->first) == kKeepEntry) {
+        ++it;
+      } else {
+        live_.erase(it++);
+      }
+    }
+  }
+
+  bool IsTrackedForTesting(Key key);
+
+ private:
+  typedef std::map<Key, Value> TrackingMap;
+
+  Heap* heap_;
+
+  // |live_| maps tracked JSArrayBuffers to the internally allocated backing
+  // store and length.
+  // For each GC round (Scavenger, or incremental/full MC)

[Hannes Payer (out of office), 2016/05/11 11:12:34]

We do not have to talk about GC type here.

[Michael Lippautz, 2016/05/11 18:43:26]

Done.

+  // |not_yet_discovered_| is initialized as a copy of |live_|. Upon finding
+  // a JSArrayBuffer during GC, the buffer is removed from
+  // |not_yet_discovered_|. At the end of a GC, we free up the remaining
+  // JSArrayBuffers in |not_yet_discovered_|.
+  TrackingMap live_;
+  TrackingMap not_yet_discovered_;
+};
+
 class ArrayBufferTracker {
  public:
   explicit ArrayBufferTracker(Heap* heap) : heap_(heap) {}
   ~ArrayBufferTracker();
 
-  inline Heap* heap() { return heap_; }
-
   // The following methods are used to track raw C++ pointers to externally
   // allocated memory used as backing store in live array buffers.
 
-  // A new ArrayBuffer was created with |data| as backing store.
-  void RegisterNew(JSArrayBuffer* buffer);
-
-  // The backing store |data| is no longer owned by V8.
+  // Register/unregsiter a new JSArrayBuffer |buffer| for tracking.
+  // |track_live| indicates whether marking will still visit the buffer and we
+  // can delay marking it as live.
+  void RegisterNew(JSArrayBuffer* buffer, bool track_live);
   void Unregister(JSArrayBuffer* buffer);
 
-  // A live ArrayBuffer was discovered during marking/scavenge.
-  void MarkLive(JSArrayBuffer* buffer);
-
   // Frees all backing store pointers that weren't discovered in the previous
-  // marking or scavenge phase.
-  void FreeDead(bool from_scavenge);
+  // scavenge phase.
+  void FreeDeadInNewSpace();
 
-  // Prepare for a new scavenge phase. A new marking phase is implicitly
-  // prepared by finishing the previous one.
-  void PrepareDiscoveryInNewSpace();
+  // A live JSArrayBuffer was discovered during marking/scavenge.
+  void MarkLive(JSArrayBuffer* buffer);
 
-  // An ArrayBuffer moved from new space to old space.
-  void Promote(JSArrayBuffer* buffer);
+  // Update methods used to update the tracking state of given ArrayBuffers.
+  void Promote(JSArrayBuffer* new_buffer, JSArrayBuffer* old_buffer);
+  void SemiSpaceCopy(JSArrayBuffer* new_buffer, JSArrayBuffer* old_buffer);
+  void Compact(JSArrayBuffer* new_buffer, JSArrayBuffer* old_buffer);
 
  private:
-  base::Mutex mutex_;
   Heap* heap_;
-
-  // |live_array_buffers_| maps externally allocated memory used as backing
-  // store for ArrayBuffers to the length of the respective memory blocks.
-  //
-  // At the beginning of mark/compact, |not_yet_discovered_array_buffers_| is
-  // a copy of |live_array_buffers_| and we remove pointers as we discover live
-  // ArrayBuffer objects during marking. At the end of mark/compact, the
-  // remaining memory blocks can be freed.
-  std::map<void*, size_t> live_array_buffers_;
-  std::map<void*, size_t> not_yet_discovered_array_buffers_;
-
-  // To be able to free memory held by ArrayBuffers during scavenge as well, we
-  // have a separate list of allocated memory held by ArrayBuffers in new space.
-  //
-  // Since mark/compact also evacuates the new space, all pointers in the
-  // |live_array_buffers_for_scavenge_| list are also in the
-  // |live_array_buffers_| list.
-  std::map<void*, size_t> live_array_buffers_for_scavenge_;
-  std::map<void*, size_t> not_yet_discovered_array_buffers_for_scavenge_;
 };
+
 }  // namespace internal
 }  // namespace v8
 #endif  // V8_HEAP_ARRAY_BUFFER_TRACKER_H_