Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(483)

Side by Side Diff: components/discardable_memory/common/discardable_shared_memory_heap.cc

Issue 2459733002: Move discardable memory to //components from //content (Closed)
Patch Set: Fix build error in ios Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698