Line data Source code
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 <unordered_map>
9 :
10 : #include "src/allocation.h"
11 : #include "src/base/platform/mutex.h"
12 : #include "src/globals.h"
13 : #include "src/objects/js-array-buffer.h"
14 :
15 : namespace v8 {
16 : namespace internal {
17 :
18 : class MarkingState;
19 : class Page;
20 : class Space;
21 :
22 : class ArrayBufferTracker : public AllStatic {
23 : public:
24 : enum ProcessingMode {
25 : kUpdateForwardedRemoveOthers,
26 : kUpdateForwardedKeepOthers,
27 : };
28 :
29 : // The following methods are used to track raw C++ pointers to externally
30 : // allocated memory used as backing store in live array buffers.
31 :
32 : // Register/unregister a new JSArrayBuffer |buffer| for tracking. Guards all
33 : // access to the tracker by taking the page lock for the corresponding page.
34 : inline static void RegisterNew(Heap* heap, JSArrayBuffer buffer);
35 : inline static void Unregister(Heap* heap, JSArrayBuffer buffer);
36 :
37 : // Identifies all backing store pointers for dead JSArrayBuffers in new space.
38 : // Does not take any locks and can only be called during Scavenge.
39 : static void PrepareToFreeDeadInNewSpace(Heap* heap);
40 :
41 : // Frees all backing store pointers for dead JSArrayBuffer on a given page.
42 : // Requires marking information to be present. Requires the page lock to be
43 : // taken by the caller.
44 : template <typename MarkingState>
45 : static void FreeDead(Page* page, MarkingState* marking_state);
46 :
47 : // Frees all remaining, live or dead, array buffers on a page. Only useful
48 : // during tear down.
49 : static void FreeAll(Page* page);
50 :
51 : // Processes all array buffers on a given page. |mode| specifies the action
52 : // to perform on the buffers. Returns whether the tracker is empty or not.
53 : static bool ProcessBuffers(Page* page, ProcessingMode mode);
54 :
55 : // Returns whether a buffer is currently tracked.
56 : V8_EXPORT_PRIVATE static bool IsTracked(JSArrayBuffer buffer);
57 :
58 : // Tears down the tracker and frees up all registered array buffers.
59 : static void TearDown(Heap* heap);
60 : };
61 :
62 : // LocalArrayBufferTracker tracks internalized array buffers.
63 : //
64 : // Never use directly but instead always call through |ArrayBufferTracker|.
65 : class LocalArrayBufferTracker {
66 : public:
67 : enum CallbackResult { kKeepEntry, kUpdateEntry, kRemoveEntry };
68 : enum FreeMode { kFreeDead, kFreeAll };
69 :
70 436856 : explicit LocalArrayBufferTracker(Page* page) : page_(page) {}
71 : ~LocalArrayBufferTracker();
72 :
73 : inline void Add(JSArrayBuffer buffer, size_t length);
74 : inline void Remove(JSArrayBuffer buffer, size_t length);
75 :
76 : // Frees up array buffers.
77 : //
78 : // Sample usage:
79 : // Free([](HeapObject array_buffer) {
80 : // if (should_free_internal(array_buffer)) return true;
81 : // return false;
82 : // });
83 : template <typename Callback>
84 : void Free(Callback should_free);
85 :
86 : // Processes buffers one by one. The CallbackResult of the callback decides
87 : // what action to take on the buffer.
88 : //
89 : // Callback should be of type:
90 : // CallbackResult fn(JSArrayBuffer buffer, JSArrayBuffer* new_buffer);
91 : template <typename Callback>
92 : void Process(Callback callback);
93 :
94 : bool IsEmpty() const { return array_buffers_.empty(); }
95 :
96 : bool IsTracked(JSArrayBuffer buffer) const {
97 : return array_buffers_.find(buffer) != array_buffers_.end();
98 : }
99 :
100 : private:
101 : class Hasher {
102 : public:
103 : size_t operator()(JSArrayBuffer buffer) const {
104 555815 : return static_cast<size_t>(buffer.ptr() >> 3);
105 : }
106 : };
107 :
108 : // Keep track of the backing store and the corresponding length at time of
109 : // registering. The length is accessed from JavaScript and can be a
110 : // HeapNumber. The reason for tracking the length is that in the case of
111 : // length being a HeapNumber, the buffer and its length may be stored on
112 : // different memory pages, making it impossible to guarantee order of freeing.
113 : using TrackingData =
114 : std::unordered_map<JSArrayBuffer, JSArrayBuffer::Allocation, Hasher>;
115 :
116 : // Internal version of add that does not update counters. Requires separate
117 : // logic for updating external memory counters.
118 : inline void AddInternal(JSArrayBuffer buffer, size_t length);
119 :
120 : inline Space* space();
121 :
122 : Page* page_;
123 : // The set contains raw heap pointers which are removed by the GC upon
124 : // processing the tracker through its owning page.
125 : TrackingData array_buffers_;
126 : };
127 :
128 : } // namespace internal
129 : } // namespace v8
130 : #endif // V8_HEAP_ARRAY_BUFFER_TRACKER_H_
|