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 :
14 : namespace v8 {
15 : namespace internal {
16 :
17 : class Heap;
18 : class JSArrayBuffer;
19 : class Page;
20 :
21 : class ArrayBufferTracker : public AllStatic {
22 : public:
23 : enum ProcessingMode {
24 : kUpdateForwardedRemoveOthers,
25 : kUpdateForwardedKeepOthers,
26 : };
27 :
28 : // The following methods are used to track raw C++ pointers to externally
29 : // allocated memory used as backing store in live array buffers.
30 :
31 : // Register/unregister a new JSArrayBuffer |buffer| for tracking. Guards all
32 : // access to the tracker by taking the page lock for the corresponding page.
33 : inline static void RegisterNew(Heap* heap, JSArrayBuffer* buffer);
34 : inline static void Unregister(Heap* heap, JSArrayBuffer* buffer);
35 :
36 : // Frees all backing store pointers for dead JSArrayBuffers in new space.
37 : // Does not take any locks and can only be called during Scavenge.
38 : static void FreeDeadInNewSpace(Heap* heap);
39 :
40 : // Frees all backing store pointers for dead JSArrayBuffer on a given page.
41 : // Requires marking information to be present. Requires the page lock to be
42 : // taken by the caller.
43 : static void FreeDead(Page* page);
44 :
45 : // Frees all remaining, live or dead, array buffers on a page. Only useful
46 : // during tear down.
47 : static void FreeAll(Page* page);
48 :
49 : // Processes all array buffers on a given page. |mode| specifies the action
50 : // to perform on the buffers. Returns whether the tracker is empty or not.
51 : static bool ProcessBuffers(Page* page, ProcessingMode mode);
52 :
53 : // Returns whether a buffer is currently tracked.
54 : static bool IsTracked(JSArrayBuffer* buffer);
55 : };
56 :
57 : // LocalArrayBufferTracker tracks internalized array buffers.
58 : //
59 : // Never use directly but instead always call through |ArrayBufferTracker|.
60 : class LocalArrayBufferTracker {
61 : public:
62 : typedef JSArrayBuffer* Key;
63 : typedef size_t Value;
64 :
65 : enum CallbackResult { kKeepEntry, kUpdateEntry, kRemoveEntry };
66 : enum FreeMode { kFreeDead, kFreeAll };
67 :
68 380264 : explicit LocalArrayBufferTracker(Heap* heap) : heap_(heap) {}
69 : ~LocalArrayBufferTracker();
70 :
71 : inline void Add(Key key, const Value& value);
72 : inline Value Remove(Key key);
73 :
74 : // Frees up array buffers determined by |free_mode|.
75 : template <FreeMode free_mode>
76 : void Free();
77 :
78 : // Processes buffers one by one. The CallbackResult of the callback decides
79 : // what action to take on the buffer.
80 : //
81 : // Callback should be of type:
82 : // CallbackResult fn(JSArrayBuffer* buffer, JSArrayBuffer** new_buffer);
83 : template <typename Callback>
84 : void Process(Callback callback);
85 :
86 : bool IsEmpty() { return array_buffers_.empty(); }
87 :
88 : bool IsTracked(Key key) {
89 : return array_buffers_.find(key) != array_buffers_.end();
90 : }
91 :
92 : private:
93 : typedef std::unordered_map<Key, Value> TrackingData;
94 :
95 : Heap* heap_;
96 : TrackingData array_buffers_;
97 : };
98 :
99 : } // namespace internal
100 : } // namespace v8
101 : #endif // V8_HEAP_ARRAY_BUFFER_TRACKER_H_
|