OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium 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 "content/common/discardable_shared_memory_heap.h" | 5 #include "content/common/discardable_shared_memory_heap.h" |
6 | 6 |
7 #include "base/memory/discardable_shared_memory.h" | 7 #include "base/memory/discardable_shared_memory.h" |
8 | 8 |
9 namespace content { | 9 namespace content { |
10 namespace { | 10 namespace { |
(...skipping 11 matching lines...) Expand all Loading... |
22 DiscardableSharedMemoryHeap::Span::Span( | 22 DiscardableSharedMemoryHeap::Span::Span( |
23 base::DiscardableSharedMemory* shared_memory, | 23 base::DiscardableSharedMemory* shared_memory, |
24 size_t start, | 24 size_t start, |
25 size_t length) | 25 size_t length) |
26 : shared_memory_(shared_memory), start_(start), length_(length) { | 26 : shared_memory_(shared_memory), start_(start), length_(length) { |
27 } | 27 } |
28 | 28 |
29 DiscardableSharedMemoryHeap::Span::~Span() { | 29 DiscardableSharedMemoryHeap::Span::~Span() { |
30 } | 30 } |
31 | 31 |
| 32 DiscardableSharedMemoryHeap::ScopedMemorySegment::ScopedMemorySegment( |
| 33 DiscardableSharedMemoryHeap* heap, |
| 34 scoped_ptr<base::DiscardableSharedMemory> shared_memory, |
| 35 size_t size) |
| 36 : heap_(heap), shared_memory_(shared_memory.Pass()), size_(size) { |
| 37 } |
| 38 |
| 39 DiscardableSharedMemoryHeap::ScopedMemorySegment::~ScopedMemorySegment() { |
| 40 heap_->ReleaseMemory(shared_memory_.get(), size_); |
| 41 // Purge memory. This has no effect if already purged. |
| 42 shared_memory_->Purge(base::Time::Now()); |
| 43 } |
| 44 |
| 45 bool DiscardableSharedMemoryHeap::ScopedMemorySegment::IsUsed() const { |
| 46 return heap_->IsMemoryUsed(shared_memory_.get(), size_); |
| 47 } |
| 48 |
| 49 bool DiscardableSharedMemoryHeap::ScopedMemorySegment::IsResident() const { |
| 50 return heap_->IsMemoryResident(shared_memory_.get()); |
| 51 } |
| 52 |
32 DiscardableSharedMemoryHeap::DiscardableSharedMemoryHeap(size_t block_size) | 53 DiscardableSharedMemoryHeap::DiscardableSharedMemoryHeap(size_t block_size) |
33 : block_size_(block_size) { | 54 : block_size_(block_size), num_blocks_(0), num_free_blocks_(0) { |
34 DCHECK_NE(block_size_, 0u); | 55 DCHECK_NE(block_size_, 0u); |
35 DCHECK(IsPowerOfTwo(block_size_)); | 56 DCHECK(IsPowerOfTwo(block_size_)); |
36 } | 57 } |
37 | 58 |
38 DiscardableSharedMemoryHeap::~DiscardableSharedMemoryHeap() { | 59 DiscardableSharedMemoryHeap::~DiscardableSharedMemoryHeap() { |
39 for (auto shared_memory : shared_memory_segments_) | 60 memory_segments_.clear(); |
40 ReleaseMemory(shared_memory); | 61 DCHECK_EQ(num_blocks_, 0u); |
41 | 62 DCHECK_EQ(num_free_blocks_, 0u); |
42 DCHECK(free_spans_.empty()); | 63 DCHECK(free_spans_.empty()); |
43 } | 64 } |
44 | 65 |
45 scoped_ptr<DiscardableSharedMemoryHeap::Span> DiscardableSharedMemoryHeap::Grow( | 66 scoped_ptr<DiscardableSharedMemoryHeap::Span> DiscardableSharedMemoryHeap::Grow( |
46 scoped_ptr<base::DiscardableSharedMemory> shared_memory, | 67 scoped_ptr<base::DiscardableSharedMemory> shared_memory, |
47 size_t size) { | 68 size_t size) { |
48 // Memory must be aligned to block size. | 69 // Memory must be aligned to block size. |
49 DCHECK_EQ( | 70 DCHECK_EQ( |
50 reinterpret_cast<size_t>(shared_memory->memory()) & (block_size_ - 1), | 71 reinterpret_cast<size_t>(shared_memory->memory()) & (block_size_ - 1), |
51 0u); | 72 0u); |
52 DCHECK_EQ(size & (block_size_ - 1), 0u); | 73 DCHECK_EQ(size & (block_size_ - 1), 0u); |
53 | 74 |
54 scoped_ptr<Span> span( | 75 scoped_ptr<Span> span( |
55 new Span(shared_memory.get(), | 76 new Span(shared_memory.get(), |
56 reinterpret_cast<size_t>(shared_memory->memory()) / block_size_, | 77 reinterpret_cast<size_t>(shared_memory->memory()) / block_size_, |
57 size / block_size_)); | 78 size / block_size_)); |
58 DCHECK(spans_.find(span->start_) == spans_.end()); | 79 DCHECK(spans_.find(span->start_) == spans_.end()); |
59 DCHECK(spans_.find(span->start_ + span->length_ - 1) == spans_.end()); | 80 DCHECK(spans_.find(span->start_ + span->length_ - 1) == spans_.end()); |
60 RegisterSpan(span.get()); | 81 RegisterSpan(span.get()); |
61 | 82 |
62 // Start tracking if segment is resident by adding it to | 83 num_blocks_ += span->length_; |
63 // |shared_memory_segments_|. | 84 |
64 shared_memory_segments_.push_back(shared_memory.release()); | 85 // Start tracking if segment is resident by adding it to |memory_segments_|. |
| 86 memory_segments_.push_back( |
| 87 new ScopedMemorySegment(this, shared_memory.Pass(), size)); |
65 | 88 |
66 return span.Pass(); | 89 return span.Pass(); |
67 } | 90 } |
68 | 91 |
69 void DiscardableSharedMemoryHeap::MergeIntoFreeList(scoped_ptr<Span> span) { | 92 void DiscardableSharedMemoryHeap::MergeIntoFreeList(scoped_ptr<Span> span) { |
70 DCHECK(span->shared_memory_); | 93 DCHECK(span->shared_memory_); |
71 | 94 |
| 95 // First add length of |span| to |num_free_blocks_|. |
| 96 num_free_blocks_ += span->length_; |
| 97 |
72 // Merge with previous span if possible. | 98 // Merge with previous span if possible. |
73 SpanMap::iterator prev_it = spans_.find(span->start_ - 1); | 99 SpanMap::iterator prev_it = spans_.find(span->start_ - 1); |
74 if (prev_it != spans_.end() && IsInFreeList(prev_it->second)) { | 100 if (prev_it != spans_.end() && IsInFreeList(prev_it->second)) { |
75 scoped_ptr<Span> prev = RemoveFromFreeList(prev_it->second); | 101 scoped_ptr<Span> prev = RemoveFromFreeList(prev_it->second); |
76 DCHECK_EQ(prev->start_ + prev->length_, span->start_); | 102 DCHECK_EQ(prev->start_ + prev->length_, span->start_); |
77 UnregisterSpan(prev.get()); | 103 UnregisterSpan(prev.get()); |
78 if (span->length_ > 1) | 104 if (span->length_ > 1) |
79 spans_.erase(span->start_); | 105 spans_.erase(span->start_); |
80 span->start_ -= prev->length_; | 106 span->start_ -= prev->length_; |
81 span->length_ += prev->length_; | 107 span->length_ += prev->length_; |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
135 if ((span->length_ == best->length_) && (span->start_ > best->start_)) | 161 if ((span->length_ == best->length_) && (span->start_ > best->start_)) |
136 continue; | 162 continue; |
137 } | 163 } |
138 | 164 |
139 best = span; | 165 best = span; |
140 } | 166 } |
141 | 167 |
142 return best ? Carve(best, blocks) : nullptr; | 168 return best ? Carve(best, blocks) : nullptr; |
143 } | 169 } |
144 | 170 |
145 size_t DiscardableSharedMemoryHeap::ReleaseFreeMemory() { | 171 void DiscardableSharedMemoryHeap::ReleaseFreeMemory() { |
146 size_t bytes_released = 0; | 172 // Erase all free segments after rearranging the segments in such a way |
147 size_t i = 0; | 173 // that used segments precede all free segments. |
| 174 memory_segments_.erase( |
| 175 std::partition( |
| 176 memory_segments_.begin(), memory_segments_.end(), |
| 177 [](const ScopedMemorySegment* segment) { return segment->IsUsed(); }), |
| 178 memory_segments_.end()); |
| 179 } |
148 | 180 |
149 // Release memory for all non-resident segments. | 181 void DiscardableSharedMemoryHeap::ReleasePurgedMemory() { |
150 while (i < shared_memory_segments_.size()) { | 182 // Erase all purged segments after rearranging the segments in such a way |
151 base::DiscardableSharedMemory* shared_memory = shared_memory_segments_[i]; | 183 // that resident segments precede all purged segments. |
| 184 memory_segments_.erase( |
| 185 std::partition(memory_segments_.begin(), memory_segments_.end(), |
| 186 [](const ScopedMemorySegment* segment) { |
| 187 return segment->IsResident(); |
| 188 }), |
| 189 memory_segments_.end()); |
| 190 } |
152 | 191 |
153 // Skip segment if still resident. | 192 size_t DiscardableSharedMemoryHeap::GetSize() const { |
154 if (shared_memory->IsMemoryResident()) { | 193 return num_blocks_ * block_size_; |
155 ++i; | 194 } |
156 continue; | |
157 } | |
158 | 195 |
159 bytes_released += shared_memory->mapped_size(); | 196 size_t DiscardableSharedMemoryHeap::GetFreeListSize() const { |
160 | 197 return num_free_blocks_ * block_size_; |
161 // Release the memory and unregistering all associated spans. | |
162 ReleaseMemory(shared_memory); | |
163 | |
164 std::swap(shared_memory_segments_[i], shared_memory_segments_.back()); | |
165 shared_memory_segments_.pop_back(); | |
166 } | |
167 | |
168 return bytes_released; | |
169 } | 198 } |
170 | 199 |
171 scoped_ptr<DiscardableSharedMemoryHeap::Span> | 200 scoped_ptr<DiscardableSharedMemoryHeap::Span> |
172 DiscardableSharedMemoryHeap::RemoveFromFreeList(Span* span) { | 201 DiscardableSharedMemoryHeap::RemoveFromFreeList(Span* span) { |
173 span->RemoveFromList(); | 202 span->RemoveFromList(); |
174 return make_scoped_ptr(span); | 203 return make_scoped_ptr(span); |
175 } | 204 } |
176 | 205 |
177 scoped_ptr<DiscardableSharedMemoryHeap::Span> | 206 scoped_ptr<DiscardableSharedMemoryHeap::Span> |
178 DiscardableSharedMemoryHeap::Carve(Span* span, size_t blocks) { | 207 DiscardableSharedMemoryHeap::Carve(Span* span, size_t blocks) { |
179 scoped_ptr<Span> serving = RemoveFromFreeList(span); | 208 scoped_ptr<Span> serving = RemoveFromFreeList(span); |
180 | 209 |
181 const int extra = serving->length_ - blocks; | 210 const int extra = serving->length_ - blocks; |
182 if (extra) { | 211 if (extra) { |
183 scoped_ptr<Span> leftover( | 212 scoped_ptr<Span> leftover( |
184 new Span(serving->shared_memory_, serving->start_ + blocks, extra)); | 213 new Span(serving->shared_memory_, serving->start_ + blocks, extra)); |
185 DCHECK_IMPLIES(extra > 1, spans_.find(leftover->start_) == spans_.end()); | 214 DCHECK_IMPLIES(extra > 1, spans_.find(leftover->start_) == spans_.end()); |
186 RegisterSpan(leftover.get()); | 215 RegisterSpan(leftover.get()); |
187 | 216 |
188 // No need to coalesce as the previous span of |leftover| was just split | 217 // No need to coalesce as the previous span of |leftover| was just split |
189 // and the next span of |leftover| was not previously coalesced with | 218 // and the next span of |leftover| was not previously coalesced with |
190 // |span|. | 219 // |span|. |
191 free_spans_.Append(leftover.release()); | 220 free_spans_.Append(leftover.release()); |
192 | 221 |
193 serving->length_ = blocks; | 222 serving->length_ = blocks; |
194 spans_[serving->start_ + blocks - 1] = serving.get(); | 223 spans_[serving->start_ + blocks - 1] = serving.get(); |
195 } | 224 } |
196 | 225 |
| 226 // |serving| is no longer in the free list, remove its length from |
| 227 // |num_free_blocks_|. |
| 228 DCHECK_GE(num_free_blocks_, serving->length_); |
| 229 num_free_blocks_ -= serving->length_; |
| 230 |
197 return serving.Pass(); | 231 return serving.Pass(); |
198 } | 232 } |
199 | 233 |
200 void DiscardableSharedMemoryHeap::RegisterSpan(Span* span) { | 234 void DiscardableSharedMemoryHeap::RegisterSpan(Span* span) { |
201 spans_[span->start_] = span; | 235 spans_[span->start_] = span; |
202 if (span->length_ > 1) | 236 if (span->length_ > 1) |
203 spans_[span->start_ + span->length_ - 1] = span; | 237 spans_[span->start_ + span->length_ - 1] = span; |
204 } | 238 } |
205 | 239 |
206 void DiscardableSharedMemoryHeap::UnregisterSpan(Span* span) { | 240 void DiscardableSharedMemoryHeap::UnregisterSpan(Span* span) { |
207 DCHECK(spans_.find(span->start_) != spans_.end()); | 241 DCHECK(spans_.find(span->start_) != spans_.end()); |
208 DCHECK_EQ(spans_[span->start_], span); | 242 DCHECK_EQ(spans_[span->start_], span); |
209 spans_.erase(span->start_); | 243 spans_.erase(span->start_); |
210 if (span->length_ > 1) { | 244 if (span->length_ > 1) { |
211 DCHECK(spans_.find(span->start_ + span->length_ - 1) != spans_.end()); | 245 DCHECK(spans_.find(span->start_ + span->length_ - 1) != spans_.end()); |
212 DCHECK_EQ(spans_[span->start_ + span->length_ - 1], span); | 246 DCHECK_EQ(spans_[span->start_ + span->length_ - 1], span); |
213 spans_.erase(span->start_ + span->length_ - 1); | 247 spans_.erase(span->start_ + span->length_ - 1); |
214 } | 248 } |
215 } | 249 } |
216 | 250 |
217 void DiscardableSharedMemoryHeap::ReleaseMemory( | 251 bool DiscardableSharedMemoryHeap::IsMemoryUsed( |
218 base::DiscardableSharedMemory* shared_memory) { | 252 const base::DiscardableSharedMemory* shared_memory, |
| 253 size_t size) { |
219 size_t offset = | 254 size_t offset = |
220 reinterpret_cast<size_t>(shared_memory->memory()) / block_size_; | 255 reinterpret_cast<size_t>(shared_memory->memory()) / block_size_; |
221 size_t end = offset + shared_memory->mapped_size() / block_size_; | 256 size_t length = size / block_size_; |
| 257 DCHECK(spans_.find(offset) != spans_.end()); |
| 258 Span* span = spans_[offset]; |
| 259 DCHECK_LE(span->length_, length); |
| 260 // Memory is used if first span is not in free list or shorter than segment. |
| 261 return !IsInFreeList(span) || span->length_ != length; |
| 262 } |
| 263 |
| 264 bool DiscardableSharedMemoryHeap::IsMemoryResident( |
| 265 const base::DiscardableSharedMemory* shared_memory) { |
| 266 return shared_memory->IsMemoryResident(); |
| 267 } |
| 268 |
| 269 void DiscardableSharedMemoryHeap::ReleaseMemory( |
| 270 const base::DiscardableSharedMemory* shared_memory, |
| 271 size_t size) { |
| 272 size_t offset = |
| 273 reinterpret_cast<size_t>(shared_memory->memory()) / block_size_; |
| 274 size_t end = offset + size / block_size_; |
222 while (offset < end) { | 275 while (offset < end) { |
223 DCHECK(spans_.find(offset) != spans_.end()); | 276 DCHECK(spans_.find(offset) != spans_.end()); |
224 Span* span = spans_[offset]; | 277 Span* span = spans_[offset]; |
225 DCHECK_EQ(span->shared_memory_, shared_memory); | 278 DCHECK_EQ(span->shared_memory_, shared_memory); |
226 span->shared_memory_ = nullptr; | 279 span->shared_memory_ = nullptr; |
227 UnregisterSpan(span); | 280 UnregisterSpan(span); |
228 | 281 |
229 offset += span->length_; | 282 offset += span->length_; |
230 | 283 |
231 // If |span| is in the free list, remove it. | 284 DCHECK_GE(num_blocks_, span->length_); |
232 if (IsInFreeList(span)) | 285 num_blocks_ -= span->length_; |
| 286 |
| 287 // If |span| is in the free list, remove it and update |num_free_blocks_|. |
| 288 if (IsInFreeList(span)) { |
| 289 DCHECK_GE(num_free_blocks_, span->length_); |
| 290 num_free_blocks_ -= span->length_; |
233 RemoveFromFreeList(span); | 291 RemoveFromFreeList(span); |
| 292 } |
234 } | 293 } |
235 } | 294 } |
236 | 295 |
237 } // namespace content | 296 } // namespace content |
OLD | NEW |