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:
ArrayBufferTracker(Heap * heap)21   explicit ArrayBufferTracker(Heap* heap) : heap_(heap) {}
22   ~ArrayBufferTracker();
23 
heap()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_
74