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/atomic_sequence_num.h"
 #include "base/memory/discardable_shared_memory.h"
+#include "base/strings/stringprintf.h"
 
 namespace content {
 namespace {
 
+const char kMemoryAllocatorHeapNamePrefix[] = "segment_%zu";
+const char kMemoryAllocatorName[] = "discardable";
+
+// Global atomic to generate unique discardable shared memory IDs.
+base::StaticAtomicSequenceNumber g_next_discardable_shared_memory_id;
+
 bool IsPowerOfTwo(size_t x) {
   return (x & (x - 1)) == 0;
 }
 
 bool IsInFreeList(DiscardableSharedMemoryHeap::Span* span) {
   return span->previous() || span->next();
 }
 
 }  // namespace
 
 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::ScopedMemorySegment::ScopedMemorySegment(
     DiscardableSharedMemoryHeap* heap,
     scoped_ptr<base::DiscardableSharedMemory> shared_memory,
     size_t size,
+    DiscardableSharedMemoryId id,
     const base::Closure& deleted_callback)
     : heap_(heap),
       shared_memory_(shared_memory.Pass()),
       size_(size),
+      id_(id),
       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::DumpMemoryStatisticsInto(
+    base::trace_event::ProcessMemoryDump* pmd) const {
+  heap_->DumpSegmentStatistics(shared_memory_.get(), size_, id_, pmd);
+}
+
 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 17 matching lines @@
   scoped_ptr<Span> span(
       new Span(shared_memory.get(),
                reinterpret_cast<size_t>(shared_memory->memory()) / block_size_,
                size / block_size_));
   DCHECK(spans_.find(span->start_) == spans_.end());
   DCHECK(spans_.find(span->start_ + span->length_ - 1) == spans_.end());
   RegisterSpan(span.get());
 
   num_blocks_ += span->length_;
 
+  DiscardableSharedMemoryId new_id =
+      g_next_discardable_shared_memory_id.GetNext();

[reveman, 2015/04/27 13:28:11]

Please pass the ID as a parameter instead. ChildDiscardableSharedMemoryManager
has an ID for each segment already and that ID is global and known to the child
process.

[ssid, 2015/04/27 14:27:01]

Oh i dint realize, thanks.

+
   // Start tracking if segment is resident by adding it to |memory_segments_|.
-  memory_segments_.push_back(new ScopedMemorySegment(this, shared_memory.Pass(),
-                                                     size, deleted_callback));
+  memory_segments_.push_back(new ScopedMemorySegment(
+      this, shared_memory.Pass(), size, new_id, deleted_callback));
 
   return span.Pass();
 }
 
 void DiscardableSharedMemoryHeap::MergeIntoFreeLists(scoped_ptr<Span> span) {
   DCHECK(span->shared_memory_);
 
   // First add length of |span| to |num_free_blocks_|.
   num_free_blocks_ += span->length_;
 
@@ skipping 97 matching lines @@
 }
 
 size_t DiscardableSharedMemoryHeap::GetSize() const {
   return num_blocks_ * block_size_;
 }
 
 size_t DiscardableSharedMemoryHeap::GetSizeOfFreeLists() const {
   return num_free_blocks_ * block_size_;
 }
 
+bool DiscardableSharedMemoryHeap::DumpMemoryStatisticsInto(
+    base::trace_event::ProcessMemoryDump* pmd) {
+  std::for_each(memory_segments_.begin(), memory_segments_.end(),
+                [pmd](const ScopedMemorySegment* segment) {
+                  segment->DumpMemoryStatisticsInto(pmd);
+                });
+  return true;
+}
+
 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 84 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);
     }
   }
 }
 
+void DiscardableSharedMemoryHeap::DumpSegmentStatistics(
+    const base::DiscardableSharedMemory* shared_memory,
+    size_t segment_size,

[reveman, 2015/04/27 13:28:11]

nit: s/segment_size/size/ to be consistent with ReleaseMemory.

[ssid, 2015/04/27 14:27:01]

Done.

+    DiscardableSharedMemoryId id,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  std::string segment_id =

[reveman, 2015/04/27 13:28:11]

nit: maybe heap_name instead

[ssid, 2015/04/27 14:27:01]

Done.

+      base::StringPrintf(kMemoryAllocatorHeapNamePrefix, id);
+  base::trace_event::MemoryAllocatorDump* segment_dump =

[reveman, 2015/04/27 13:28:11]

fyi, "dump" is enough if the cleans things up, up to you.

[ssid, 2015/04/27 14:27:01]

Done.

+      pmd->CreateAllocatorDump(kMemoryAllocatorName, segment_id.c_str());

[reveman, 2015/04/27 13:28:11]

What if this fails? Looks like other dump providers handle that by returning
false..

[ssid, 2015/04/27 14:27:01]

The check is unnecessary, will be removed in other dump providers.

[reveman, 2015/04/27 15:08:58]

Acknowledged.

+
+  size_t allocated_objects_count = 0;
+  size_t allocated_objects_size_in_bytes = 0;
+  size_t offset =
+      reinterpret_cast<size_t>(shared_memory->memory()) / block_size_;
+  size_t end = offset + segment_size / block_size_;
+  while (offset < end) {
+    Span* span = spans_[offset];
+    if (!IsInFreeList(span)) {
+      allocated_objects_count++;
+      allocated_objects_size_in_bytes += span->length_;
+    }
+    offset += span->length_;
+  }
+
+  segment_dump->set_physical_size_in_bytes(static_cast<uint64>(segment_size));
+  segment_dump->set_allocated_objects_count(
+      static_cast<uint64>(allocated_objects_count));
+  segment_dump->set_allocated_objects_size_in_bytes(
+      static_cast<uint64>(allocated_objects_size_in_bytes));

[reveman, 2015/04/27 13:28:11]

are these static_casts really needed?

[ssid, 2015/04/27 14:27:01]

yes, since windows build gives conversion error from size_t to int.

[reveman, 2015/04/27 15:08:58]

hm, I would expect size_t to uint64 to always be ok

+}
+
 }  // namespace content