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 "components/discardable_memory/common/discardable_shared_memory_heap.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/format_macros.h" | 10 #include "base/format_macros.h" |
11 #include "base/macros.h" | 11 #include "base/macros.h" |
12 #include "base/memory/discardable_shared_memory.h" | 12 #include "base/memory/discardable_shared_memory.h" |
13 #include "base/memory/ptr_util.h" | 13 #include "base/memory/ptr_util.h" |
14 #include "base/strings/stringprintf.h" | 14 #include "base/strings/stringprintf.h" |
15 #include "base/trace_event/memory_dump_manager.h" | 15 #include "base/trace_event/memory_dump_manager.h" |
16 | 16 |
17 namespace content { | 17 namespace discardable_memory { |
18 namespace { | 18 namespace { |
19 | 19 |
20 bool IsPowerOfTwo(size_t x) { | 20 bool IsPowerOfTwo(size_t x) { |
21 return (x & (x - 1)) == 0; | 21 return (x & (x - 1)) == 0; |
22 } | 22 } |
23 | 23 |
24 bool IsInFreeList(DiscardableSharedMemoryHeap::Span* span) { | 24 bool IsInFreeList(DiscardableSharedMemoryHeap::Span* span) { |
25 return span->previous() || span->next(); | 25 return span->previous() || span->next(); |
26 } | 26 } |
27 | 27 |
28 } // namespace | 28 } // namespace |
29 | 29 |
30 DiscardableSharedMemoryHeap::Span::Span( | 30 DiscardableSharedMemoryHeap::Span::Span( |
31 base::DiscardableSharedMemory* shared_memory, | 31 base::DiscardableSharedMemory* shared_memory, |
32 size_t start, | 32 size_t start, |
33 size_t length) | 33 size_t length) |
34 : shared_memory_(shared_memory), | 34 : shared_memory_(shared_memory), |
35 start_(start), | 35 start_(start), |
36 length_(length), | 36 length_(length), |
37 is_locked_(false) {} | 37 is_locked_(false) {} |
38 | 38 |
39 DiscardableSharedMemoryHeap::Span::~Span() { | 39 DiscardableSharedMemoryHeap::Span::~Span() {} |
40 } | |
41 | 40 |
42 DiscardableSharedMemoryHeap::ScopedMemorySegment::ScopedMemorySegment( | 41 DiscardableSharedMemoryHeap::ScopedMemorySegment::ScopedMemorySegment( |
43 DiscardableSharedMemoryHeap* heap, | 42 DiscardableSharedMemoryHeap* heap, |
44 std::unique_ptr<base::DiscardableSharedMemory> shared_memory, | 43 std::unique_ptr<base::DiscardableSharedMemory> shared_memory, |
45 size_t size, | 44 size_t size, |
46 int32_t id, | 45 int32_t id, |
47 const base::Closure& deleted_callback) | 46 const base::Closure& deleted_callback) |
48 : heap_(heap), | 47 : heap_(heap), |
49 shared_memory_(std::move(shared_memory)), | 48 shared_memory_(std::move(shared_memory)), |
50 size_(size), | 49 size_(size), |
(...skipping 196 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
247 size_t DiscardableSharedMemoryHeap::GetSize() const { | 246 size_t DiscardableSharedMemoryHeap::GetSize() const { |
248 return num_blocks_ * block_size_; | 247 return num_blocks_ * block_size_; |
249 } | 248 } |
250 | 249 |
251 size_t DiscardableSharedMemoryHeap::GetSizeOfFreeLists() const { | 250 size_t DiscardableSharedMemoryHeap::GetSizeOfFreeLists() const { |
252 return num_free_blocks_ * block_size_; | 251 return num_free_blocks_ * block_size_; |
253 } | 252 } |
254 | 253 |
255 bool DiscardableSharedMemoryHeap::OnMemoryDump( | 254 bool DiscardableSharedMemoryHeap::OnMemoryDump( |
256 base::trace_event::ProcessMemoryDump* pmd) { | 255 base::trace_event::ProcessMemoryDump* pmd) { |
257 std::for_each( | 256 std::for_each(memory_segments_.begin(), memory_segments_.end(), |
258 memory_segments_.begin(), memory_segments_.end(), | 257 [pmd](const ScopedMemorySegment* segment) { |
259 [pmd](const ScopedMemorySegment* segment) { | 258 segment->OnMemoryDump(pmd); |
260 segment->OnMemoryDump(pmd); | 259 }); |
261 }); | |
262 return true; | 260 return true; |
263 } | 261 } |
264 | 262 |
265 void DiscardableSharedMemoryHeap::InsertIntoFreeList( | 263 void DiscardableSharedMemoryHeap::InsertIntoFreeList( |
266 std::unique_ptr<DiscardableSharedMemoryHeap::Span> span) { | 264 std::unique_ptr<DiscardableSharedMemoryHeap::Span> span) { |
267 DCHECK(!IsInFreeList(span.get())); | 265 DCHECK(!IsInFreeList(span.get())); |
268 size_t index = std::min(span->length_, arraysize(free_spans_)) - 1; | 266 size_t index = std::min(span->length_, arraysize(free_spans_)) - 1; |
269 free_spans_[index].Append(span.release()); | 267 free_spans_[index].Append(span.release()); |
270 } | 268 } |
271 | 269 |
272 std::unique_ptr<DiscardableSharedMemoryHeap::Span> | 270 std::unique_ptr<DiscardableSharedMemoryHeap::Span> |
273 DiscardableSharedMemoryHeap::RemoveFromFreeList(Span* span) { | 271 DiscardableSharedMemoryHeap::RemoveFromFreeList(Span* span) { |
274 DCHECK(IsInFreeList(span)); | 272 DCHECK(IsInFreeList(span)); |
275 span->RemoveFromList(); | 273 span->RemoveFromList(); |
276 return base::WrapUnique(span); | 274 return base::WrapUnique(span); |
277 } | 275 } |
278 | 276 |
279 std::unique_ptr<DiscardableSharedMemoryHeap::Span> | 277 std::unique_ptr<DiscardableSharedMemoryHeap::Span> |
280 DiscardableSharedMemoryHeap::Carve(Span* span, size_t blocks) { | 278 DiscardableSharedMemoryHeap::Carve(Span* span, size_t blocks) { |
281 std::unique_ptr<Span> serving = RemoveFromFreeList(span); | 279 std::unique_ptr<Span> serving = RemoveFromFreeList(span); |
282 | 280 |
283 const int extra = serving->length_ - blocks; | 281 const size_t extra = serving->length_ - blocks; |
reveman
2016/10/31 22:46:02
did you need this to fix the build? just curious
Peng
2016/11/01 14:26:18
Yes. It causes a warning on WIN build. Not sure wh
| |
284 if (extra) { | 282 if (extra) { |
285 std::unique_ptr<Span> leftover( | 283 std::unique_ptr<Span> leftover( |
286 new Span(serving->shared_memory_, serving->start_ + blocks, extra)); | 284 new Span(serving->shared_memory_, serving->start_ + blocks, extra)); |
287 leftover->set_is_locked(false); | 285 leftover->set_is_locked(false); |
288 DCHECK(extra == 1 || spans_.find(leftover->start_) == spans_.end()); | 286 DCHECK(extra == 1 || spans_.find(leftover->start_) == spans_.end()); |
289 RegisterSpan(leftover.get()); | 287 RegisterSpan(leftover.get()); |
290 | 288 |
291 // No need to coalesce as the previous span of |leftover| was just split | 289 // No need to coalesce as the previous span of |leftover| was just split |
292 // and the next span of |leftover| was not previously coalesced with | 290 // and the next span of |leftover| was not previously coalesced with |
293 // |span|. | 291 // |span|. |
(...skipping 173 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
467 | 465 |
468 ScopedVector<ScopedMemorySegment>::const_iterator it = | 466 ScopedVector<ScopedMemorySegment>::const_iterator it = |
469 std::find_if(memory_segments_.begin(), memory_segments_.end(), | 467 std::find_if(memory_segments_.begin(), memory_segments_.end(), |
470 [span](const ScopedMemorySegment* segment) { | 468 [span](const ScopedMemorySegment* segment) { |
471 return segment->ContainsSpan(span); | 469 return segment->ContainsSpan(span); |
472 }); | 470 }); |
473 DCHECK(it != memory_segments_.end()); | 471 DCHECK(it != memory_segments_.end()); |
474 return (*it)->CreateMemoryAllocatorDump(span, block_size_, name, pmd); | 472 return (*it)->CreateMemoryAllocatorDump(span, block_size_, name, pmd); |
475 } | 473 } |
476 | 474 |
477 } // namespace content | 475 } // namespace discardable_memory |
OLD | NEW |