Adding discardable memory dump provider.

content/common/discardable_shared_memory_heap.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/common/discardable_shared_memory_heap.h"
 
 #include <algorithm>
 
 #include "base/memory/discardable_shared_memory.h"
 
@@ skipping 13 matching lines @@
 DiscardableSharedMemoryHeap::Span::Span(
     base::DiscardableSharedMemory* shared_memory,
     size_t start,
     size_t length)
     : shared_memory_(shared_memory), start_(start), length_(length) {
 }
 
 DiscardableSharedMemoryHeap::Span::~Span() {
 }
 
+DiscardableSharedMemoryHeap::MemoryStatistics::MemoryStatistics() {
+}
+
+DiscardableSharedMemoryHeap::MemoryStatistics::~MemoryStatistics() {
+}
+
 DiscardableSharedMemoryHeap::ScopedMemorySegment::ScopedMemorySegment(
     DiscardableSharedMemoryHeap* heap,
     scoped_ptr<base::DiscardableSharedMemory> shared_memory,
     size_t size,
     const base::Closure& deleted_callback)
     : heap_(heap),
       shared_memory_(shared_memory.Pass()),
       size_(size),
       deleted_callback_(deleted_callback) {
 }
 
 DiscardableSharedMemoryHeap::ScopedMemorySegment::~ScopedMemorySegment() {
   heap_->ReleaseMemory(shared_memory_.get(), size_);
   deleted_callback_.Run();
 }
 
 bool DiscardableSharedMemoryHeap::ScopedMemorySegment::IsUsed() const {
   return heap_->IsMemoryUsed(shared_memory_.get(), size_);
 }
 
 bool DiscardableSharedMemoryHeap::ScopedMemorySegment::IsResident() const {
   return heap_->IsMemoryResident(shared_memory_.get());
 }
 
+void DiscardableSharedMemoryHeap::ScopedMemorySegment::GetStatistics(
+    MemoryStatistics::SegmentStatistics* segment_stats) {

[reveman, 2015/04/23 17:32:30]

I prefer if this was kept consistent with
DiscardableSharedMemoryHeap::ReleaseMemory. ie. a private
DiscardableSharedMemoryHeap function rather than a ScopedMemorySegment function.

[ssid, 2015/04/23 18:03:07]

shared_memory is private field here, not shared with the heap class. Do you
suggest sharing the member or having friend class?
Else we can have a proxy function which calls back by passing shared_memory to
heap, but code wouldn't be readable.

[reveman, 2015/04/23 18:11:53]

I think Heap class is already a friend.

[ssid, 2015/04/24 11:23:04]

Made it friend now.

+  segment_stats->size = size_;
+  size_t offset =
+      reinterpret_cast<size_t>(shared_memory_->memory()) / heap_->block_size_;
+  segment_stats->num_of_objects = 0;
+  segment_stats->used_size = 0;
+  size_t end = offset + size_ / heap_->block_size_;
+  while (offset < end) {
+    Span* span = heap_->spans_[offset];
+    if (!IsInFreeList(span)) {
+      segment_stats->num_of_objects++;
+      segment_stats->used_size += span->length_;
+    }
+    offset += span->length_;
+  }
+}
+
 DiscardableSharedMemoryHeap::DiscardableSharedMemoryHeap(size_t block_size)
     : block_size_(block_size), num_blocks_(0), num_free_blocks_(0) {
   DCHECK_NE(block_size_, 0u);
   DCHECK(IsPowerOfTwo(block_size_));
 }
 
 DiscardableSharedMemoryHeap::~DiscardableSharedMemoryHeap() {
   memory_segments_.clear();
   DCHECK_EQ(num_blocks_, 0u);
   DCHECK_EQ(num_free_blocks_, 0u);
@@ skipping 137 matching lines @@
 }
 
 size_t DiscardableSharedMemoryHeap::GetSize() const {
   return num_blocks_ * block_size_;
 }
 
 size_t DiscardableSharedMemoryHeap::GetSizeOfFreeLists() const {
   return num_free_blocks_ * block_size_;
 }
 
+void DiscardableSharedMemoryHeap::GetMemoryStatistics(
+    DiscardableSharedMemoryHeap::MemoryStatistics* statistics) {
+  statistics->block_size = block_size_;
+  statistics->total_size = GetSize();
+  statistics->total_used_size = statistics->total_size - GetSizeOfFreeLists();
+  statistics->total_objects = 0;
+  for (size_t i = 0; i < memory_segments_.size(); i++) {
+    MemoryStatistics::SegmentStatistics segment_stats;
+    memory_segments_[i]->GetStatistics(&segment_stats);
+    statistics->segments_stats.push_back(segment_stats);
+    statistics->total_objects += segment_stats.num_of_objects;
+  }
+}
+
 void DiscardableSharedMemoryHeap::InsertIntoFreeList(
     scoped_ptr<DiscardableSharedMemoryHeap::Span> span) {
   DCHECK(!IsInFreeList(span.get()));
   size_t index = std::min(span->length_, arraysize(free_spans_)) - 1;
   free_spans_[index].Append(span.release());
 }
 
 scoped_ptr<DiscardableSharedMemoryHeap::Span>
 DiscardableSharedMemoryHeap::RemoveFromFreeList(Span* span) {
   DCHECK(IsInFreeList(span));
@@ skipping 85 matching lines @@
     // If |span| is in the free list, remove it and update |num_free_blocks_|.
     if (IsInFreeList(span)) {
       DCHECK_GE(num_free_blocks_, span->length_);
       num_free_blocks_ -= span->length_;
       RemoveFromFreeList(span);
     }
   }
 }
 
 }  // namespace content