src/heap/array-buffer-tracker.h

   1 // Copyright 2015 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_HEAP_ARRAY_BUFFER_TRACKER_H_
   6 #define V8_HEAP_ARRAY_BUFFER_TRACKER_H_
   7
   8 #include <map>
   9
  10 #include "src/globals.h"
  11
  12 namespace v8 {
  13 namespace internal {
  14
  15 // Forward declarations.
  16 class Heap;
  17 class JSArrayBuffer;
  18
  19 class ArrayBufferTracker {
  20  public:
  21   explicit ArrayBufferTracker(Heap* heap) : heap_(heap) {}
  22   ~ArrayBufferTracker();
  23
  24   inline Heap* heap() { return heap_; }
  25
  26   // The following methods are used to track raw C++ pointers to externally
  27   // allocated memory used as backing store in live array buffers.
  28
  29   // A new ArrayBuffer was created with |data| as backing store.
  30   void RegisterNew(JSArrayBuffer* buffer);
  31
  32   // The backing store |data| is no longer owned by V8.
  33   void Unregister(JSArrayBuffer* buffer);
  34
  35   // A live ArrayBuffer was discovered during marking/scavenge.
  36   void MarkLive(JSArrayBuffer* buffer);
  37
  38   // Frees all backing store pointers that weren't discovered in the previous
  39   // marking or scavenge phase.
  40   void FreeDead(bool from_scavenge);
  41
  42   // Prepare for a new scavenge phase. A new marking phase is implicitly
  43   // prepared by finishing the previous one.
  44   void PrepareDiscoveryInNewSpace();
  45
  46   // An ArrayBuffer moved from new space to old space.
  47   void Promote(JSArrayBuffer* buffer);
  48
  49  private:
  50   Heap* heap_;
  51
  52   // |live_array_buffers_| maps externally allocated memory used as backing
  53   // store for ArrayBuffers to the length of the respective memory blocks.
  54   //
  55   // At the beginning of mark/compact, |not_yet_discovered_array_buffers_| is
  56   // a copy of |live_array_buffers_| and we remove pointers as we discover live
  57   // ArrayBuffer objects during marking. At the end of mark/compact, the
  58   // remaining memory blocks can be freed.
  59   std::map<void*, size_t> live_array_buffers_;
  60   std::map<void*, size_t> not_yet_discovered_array_buffers_;
  61
  62   // To be able to free memory held by ArrayBuffers during scavenge as well, we
  63   // have a separate list of allocated memory held by ArrayBuffers in new space.
  64   //
  65   // Since mark/compact also evacuates the new space, all pointers in the
  66   // |live_array_buffers_for_scavenge_| list are also in the
  67   // |live_array_buffers_| list.
  68   std::map<void*, size_t> live_array_buffers_for_scavenge_;
  69   std::map<void*, size_t> not_yet_discovered_array_buffers_for_scavenge_;
  70 };
  71 }  // namespace internal
  72 }  // namespace v8
  73 #endif  // V8_HEAP_ARRAY_BUFFER_TRACKER_H_