OLD | NEW |
1 // Copyright 2015 the V8 project authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/heap/array-buffer-tracker.h" | 5 #include "src/heap/array-buffer-tracker.h" |
6 #include "src/heap/heap.h" | 6 #include "src/heap/heap.h" |
7 #include "src/isolate.h" | 7 #include "src/isolate.h" |
| 8 #include "src/objects-inl.h" |
8 #include "src/objects.h" | 9 #include "src/objects.h" |
9 #include "src/objects-inl.h" | |
10 #include "src/v8.h" | 10 #include "src/v8.h" |
11 | 11 |
12 namespace v8 { | 12 namespace v8 { |
13 namespace internal { | 13 namespace internal { |
14 | 14 |
15 ArrayBufferTracker::~ArrayBufferTracker() { | 15 LocalArrayBufferTracker::~LocalArrayBufferTracker() { |
16 Isolate* isolate = heap()->isolate(); | 16 CHECK(array_buffers_.empty()); |
| 17 } |
| 18 |
| 19 void LocalArrayBufferTracker::Add(Key key, const Value& value) { |
| 20 auto ret = array_buffers_.insert(std::make_pair(key, value)); |
| 21 USE(ret); |
| 22 // Check that we indeed inserted a new value and did not overwrite an existing |
| 23 // one (which would be a bug). |
| 24 DCHECK(ret.second); |
| 25 } |
| 26 |
| 27 LocalArrayBufferTracker::Value LocalArrayBufferTracker::Remove(Key key) { |
| 28 TrackingMap::iterator it = array_buffers_.find(key); |
| 29 DCHECK(it != array_buffers_.end()); |
| 30 Value value = it->second; |
| 31 array_buffers_.erase(it); |
| 32 return value; |
| 33 } |
| 34 |
| 35 template <LocalArrayBufferTracker::FreeMode free_mode> |
| 36 void LocalArrayBufferTracker::Free() { |
17 size_t freed_memory = 0; | 37 size_t freed_memory = 0; |
18 for (auto& buffer : live_array_buffers_) { | 38 for (TrackingMap::iterator it = array_buffers_.begin(); |
19 isolate->array_buffer_allocator()->Free(buffer.first, buffer.second); | 39 it != array_buffers_.end();) { |
20 freed_memory += buffer.second; | 40 if ((free_mode == kFreeAll) || |
| 41 Marking::IsWhite(Marking::MarkBitFrom(it->first))) { |
| 42 heap_->isolate()->array_buffer_allocator()->Free(it->second.first, |
| 43 it->second.second); |
| 44 freed_memory += it->second.second; |
| 45 it = array_buffers_.erase(it); |
| 46 } else { |
| 47 it++; |
| 48 } |
21 } | 49 } |
22 for (auto& buffer : live_array_buffers_for_scavenge_) { | |
23 isolate->array_buffer_allocator()->Free(buffer.first, buffer.second); | |
24 freed_memory += buffer.second; | |
25 } | |
26 live_array_buffers_.clear(); | |
27 live_array_buffers_for_scavenge_.clear(); | |
28 not_yet_discovered_array_buffers_.clear(); | |
29 not_yet_discovered_array_buffers_for_scavenge_.clear(); | |
30 | |
31 if (freed_memory > 0) { | 50 if (freed_memory > 0) { |
32 heap()->update_amount_of_external_allocated_memory( | 51 heap_->update_amount_of_external_allocated_freed_memory( |
33 -static_cast<int64_t>(freed_memory)); | 52 static_cast<intptr_t>(freed_memory)); |
34 } | 53 } |
35 } | 54 } |
36 | 55 |
| 56 template <typename Callback> |
| 57 void LocalArrayBufferTracker::Process(Callback callback) { |
| 58 JSArrayBuffer* new_buffer = nullptr; |
| 59 size_t freed_memory = 0; |
| 60 for (TrackingMap::iterator it = array_buffers_.begin(); |
| 61 it != array_buffers_.end();) { |
| 62 const CallbackResult result = callback(it->first, &new_buffer); |
| 63 if (result == kKeepEntry) { |
| 64 it++; |
| 65 } else if (result == kUpdateEntry) { |
| 66 DCHECK_NOT_NULL(new_buffer); |
| 67 Page* target_page = Page::FromAddress(new_buffer->address()); |
| 68 // We need to lock the target page because we cannot guarantee |
| 69 // exclusive access to new space pages. |
| 70 if (target_page->InNewSpace()) target_page->mutex()->Lock(); |
| 71 LocalArrayBufferTracker* tracker = target_page->local_tracker(); |
| 72 if (tracker == nullptr) { |
| 73 target_page->AllocateLocalTracker(); |
| 74 tracker = target_page->local_tracker(); |
| 75 } |
| 76 DCHECK_NOT_NULL(tracker); |
| 77 tracker->Add(new_buffer, it->second); |
| 78 if (target_page->InNewSpace()) target_page->mutex()->Unlock(); |
| 79 it = array_buffers_.erase(it); |
| 80 } else if (result == kRemoveEntry) { |
| 81 heap_->isolate()->array_buffer_allocator()->Free(it->second.first, |
| 82 it->second.second); |
| 83 freed_memory += it->second.second; |
| 84 it = array_buffers_.erase(it); |
| 85 } else { |
| 86 UNREACHABLE(); |
| 87 } |
| 88 } |
| 89 if (freed_memory > 0) { |
| 90 heap_->update_amount_of_external_allocated_freed_memory( |
| 91 static_cast<intptr_t>(freed_memory)); |
| 92 } |
| 93 } |
37 | 94 |
38 void ArrayBufferTracker::RegisterNew(JSArrayBuffer* buffer) { | 95 void ArrayBufferTracker::RegisterNew(Heap* heap, JSArrayBuffer* buffer) { |
39 void* data = buffer->backing_store(); | 96 void* data = buffer->backing_store(); |
40 if (!data) return; | 97 if (!data) return; |
41 | 98 |
42 bool in_new_space = heap()->InNewSpace(buffer); | 99 size_t length = NumberToSize(heap->isolate(), buffer->byte_length()); |
43 size_t length = NumberToSize(heap()->isolate(), buffer->byte_length()); | 100 Page* page = Page::FromAddress(buffer->address()); |
44 if (in_new_space) { | 101 { |
45 live_array_buffers_for_scavenge_[data] = length; | 102 base::LockGuard<base::Mutex> guard(page->mutex()); |
46 } else { | 103 LocalArrayBufferTracker* tracker = page->local_tracker(); |
47 live_array_buffers_[data] = length; | 104 if (tracker == nullptr) { |
| 105 page->AllocateLocalTracker(); |
| 106 tracker = page->local_tracker(); |
| 107 } |
| 108 DCHECK_NOT_NULL(tracker); |
| 109 tracker->Add(buffer, std::make_pair(data, length)); |
48 } | 110 } |
49 | |
50 // We may go over the limit of externally allocated memory here. We call the | 111 // We may go over the limit of externally allocated memory here. We call the |
51 // api function to trigger a GC in this case. | 112 // api function to trigger a GC in this case. |
52 reinterpret_cast<v8::Isolate*>(heap()->isolate()) | 113 reinterpret_cast<v8::Isolate*>(heap->isolate()) |
53 ->AdjustAmountOfExternalAllocatedMemory(length); | 114 ->AdjustAmountOfExternalAllocatedMemory(length); |
54 } | 115 } |
55 | 116 |
56 | 117 void ArrayBufferTracker::Unregister(Heap* heap, JSArrayBuffer* buffer) { |
57 void ArrayBufferTracker::Unregister(JSArrayBuffer* buffer) { | |
58 void* data = buffer->backing_store(); | 118 void* data = buffer->backing_store(); |
59 if (!data) return; | 119 if (!data) return; |
60 | 120 |
61 bool in_new_space = heap()->InNewSpace(buffer); | 121 Page* page = Page::FromAddress(buffer->address()); |
62 std::map<void*, size_t>* live_buffers = | 122 size_t length = 0; |
63 in_new_space ? &live_array_buffers_for_scavenge_ : &live_array_buffers_; | 123 { |
64 std::map<void*, size_t>* not_yet_discovered_buffers = | 124 base::LockGuard<base::Mutex> guard(page->mutex()); |
65 in_new_space ? ¬_yet_discovered_array_buffers_for_scavenge_ | 125 LocalArrayBufferTracker* tracker = page->local_tracker(); |
66 : ¬_yet_discovered_array_buffers_; | 126 DCHECK_NOT_NULL(tracker); |
67 | 127 length = tracker->Remove(buffer).second; |
68 DCHECK(live_buffers->count(data) > 0); | 128 } |
69 | 129 heap->update_amount_of_external_allocated_memory( |
70 size_t length = (*live_buffers)[data]; | 130 -static_cast<intptr_t>(length)); |
71 live_buffers->erase(data); | |
72 not_yet_discovered_buffers->erase(data); | |
73 | |
74 heap()->update_amount_of_external_allocated_memory( | |
75 -static_cast<int64_t>(length)); | |
76 } | 131 } |
77 | 132 |
| 133 void ArrayBufferTracker::FreeDeadInNewSpace(Heap* heap) { |
| 134 DCHECK_EQ(heap->gc_state(), Heap::HeapState::SCAVENGE); |
| 135 NewSpacePageIterator from_it(heap->new_space()->FromSpaceStart(), |
| 136 heap->new_space()->FromSpaceEnd()); |
| 137 while (from_it.has_next()) { |
| 138 Page* page = from_it.next(); |
| 139 bool empty = ProcessBuffers(page, kUpdateForwardedRemoveOthers); |
| 140 CHECK(empty); |
| 141 } |
| 142 heap->account_amount_of_external_allocated_freed_memory(); |
| 143 } |
78 | 144 |
79 void ArrayBufferTracker::MarkLive(JSArrayBuffer* buffer) { | 145 void ArrayBufferTracker::FreeDead(Page* page) { |
80 base::LockGuard<base::Mutex> guard(&mutex_); | 146 // Callers need to ensure having the page lock. |
81 void* data = buffer->backing_store(); | 147 LocalArrayBufferTracker* tracker = page->local_tracker(); |
82 | 148 if (tracker == nullptr) return; |
83 // ArrayBuffer might be in the middle of being constructed. | 149 DCHECK(!page->SweepingDone()); |
84 if (data == heap()->undefined_value()) return; | 150 tracker->Free<LocalArrayBufferTracker::kFreeDead>(); |
85 if (heap()->InNewSpace(buffer)) { | 151 if (tracker->IsEmpty()) { |
86 not_yet_discovered_array_buffers_for_scavenge_.erase(data); | 152 page->ReleaseLocalTracker(); |
87 } else { | |
88 not_yet_discovered_array_buffers_.erase(data); | |
89 } | 153 } |
90 } | 154 } |
91 | 155 |
92 | 156 void ArrayBufferTracker::FreeAll(Page* page) { |
93 void ArrayBufferTracker::FreeDead(bool from_scavenge) { | 157 LocalArrayBufferTracker* tracker = page->local_tracker(); |
94 size_t freed_memory = 0; | 158 if (tracker == nullptr) return; |
95 Isolate* isolate = heap()->isolate(); | 159 tracker->Free<LocalArrayBufferTracker::kFreeAll>(); |
96 for (auto& buffer : not_yet_discovered_array_buffers_for_scavenge_) { | 160 if (tracker->IsEmpty()) { |
97 isolate->array_buffer_allocator()->Free(buffer.first, buffer.second); | 161 page->ReleaseLocalTracker(); |
98 freed_memory += buffer.second; | |
99 live_array_buffers_for_scavenge_.erase(buffer.first); | |
100 } | 162 } |
101 | |
102 if (!from_scavenge) { | |
103 for (auto& buffer : not_yet_discovered_array_buffers_) { | |
104 isolate->array_buffer_allocator()->Free(buffer.first, buffer.second); | |
105 freed_memory += buffer.second; | |
106 live_array_buffers_.erase(buffer.first); | |
107 } | |
108 } | |
109 | |
110 not_yet_discovered_array_buffers_for_scavenge_ = | |
111 live_array_buffers_for_scavenge_; | |
112 if (!from_scavenge) not_yet_discovered_array_buffers_ = live_array_buffers_; | |
113 | |
114 // Do not call through the api as this code is triggered while doing a GC. | |
115 heap()->update_amount_of_external_allocated_memory( | |
116 -static_cast<int64_t>(freed_memory)); | |
117 } | 163 } |
118 | 164 |
| 165 bool ArrayBufferTracker::ProcessBuffers(Page* page, ProcessingMode mode) { |
| 166 LocalArrayBufferTracker* tracker = page->local_tracker(); |
| 167 if (tracker == nullptr) return true; |
119 | 168 |
120 void ArrayBufferTracker::PrepareDiscoveryInNewSpace() { | 169 DCHECK(page->SweepingDone()); |
121 not_yet_discovered_array_buffers_for_scavenge_ = | 170 tracker->Process( |
122 live_array_buffers_for_scavenge_; | 171 [mode](JSArrayBuffer* old_buffer, JSArrayBuffer** new_buffer) { |
| 172 MapWord map_word = old_buffer->map_word(); |
| 173 if (map_word.IsForwardingAddress()) { |
| 174 *new_buffer = JSArrayBuffer::cast(map_word.ToForwardingAddress()); |
| 175 return LocalArrayBufferTracker::kUpdateEntry; |
| 176 } |
| 177 return mode == kUpdateForwardedKeepOthers |
| 178 ? LocalArrayBufferTracker::kKeepEntry |
| 179 : LocalArrayBufferTracker::kRemoveEntry; |
| 180 }); |
| 181 return tracker->IsEmpty(); |
123 } | 182 } |
124 | 183 |
125 | 184 bool ArrayBufferTracker::IsTracked(JSArrayBuffer* buffer) { |
126 void ArrayBufferTracker::Promote(JSArrayBuffer* buffer) { | 185 Page* page = Page::FromAddress(buffer->address()); |
127 base::LockGuard<base::Mutex> guard(&mutex_); | 186 { |
128 | 187 base::LockGuard<base::Mutex> guard(page->mutex()); |
129 if (buffer->is_external()) return; | 188 LocalArrayBufferTracker* tracker = page->local_tracker(); |
130 void* data = buffer->backing_store(); | 189 if (tracker == nullptr) return false; |
131 if (!data) return; | 190 return tracker->IsTracked(buffer); |
132 // ArrayBuffer might be in the middle of being constructed. | 191 } |
133 if (data == heap()->undefined_value()) return; | |
134 DCHECK(live_array_buffers_for_scavenge_.count(data) > 0); | |
135 live_array_buffers_[data] = live_array_buffers_for_scavenge_[data]; | |
136 live_array_buffers_for_scavenge_.erase(data); | |
137 not_yet_discovered_array_buffers_for_scavenge_.erase(data); | |
138 } | 192 } |
139 | 193 |
140 } // namespace internal | 194 } // namespace internal |
141 } // namespace v8 | 195 } // namespace v8 |
OLD | NEW |