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 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 LocalArrayBufferTracker(Page * page)70 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 IsEmpty()94 bool IsEmpty() const { return array_buffers_.empty(); } 95 IsTracked(JSArrayBuffer * buffer)96 bool IsTracked(JSArrayBuffer* buffer) const { 97 return array_buffers_.find(buffer) != array_buffers_.end(); 98 } 99 100 private: 101 class Hasher { 102 public: operator()103 size_t operator()(JSArrayBuffer* buffer) const { 104 return reinterpret_cast<size_t>(buffer) >> 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 typedef std::unordered_map<JSArrayBuffer*, JSArrayBuffer::Allocation, Hasher> 114 TrackingData; 115 116 inline Space* space(); 117 118 Page* page_; 119 // The set contains raw heap pointers which are removed by the GC upon 120 // processing the tracker through its owning page. 121 TrackingData array_buffers_; 122 }; 123 124 } // namespace internal 125 } // namespace v8 126 #endif // V8_HEAP_ARRAY_BUFFER_TRACKER_H_ 127