content/child/child_discardable_shared_memory_manager.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include "content/child/child_discardable_shared_memory_manager.h"
   6
   7 #include "base/atomic_sequence_num.h"
   8 #include "base/bind.h"
   9 #include "base/debug/crash_logging.h"
  10 #include "base/memory/discardable_memory.h"
  11 #include "base/memory/discardable_shared_memory.h"
  12 #include "base/metrics/histogram.h"
  13 #include "base/process/memory.h"
  14 #include "base/process/process_metrics.h"
  15 #include "base/strings/string_number_conversions.h"
  16 #include "base/thread_task_runner_handle.h"
  17 #include "base/trace_event/memory_dump_manager.h"
  18 #include "base/trace_event/trace_event.h"
  19 #include "content/common/child_process_messages.h"
  20
  21 namespace content {
  22 namespace {
  23
  24 // Default allocation size.
  25 const size_t kAllocationSize = 4 * 1024 * 1024;
  26
  27 // Global atomic to generate unique discardable shared memory IDs.
  28 base::StaticAtomicSequenceNumber g_next_discardable_shared_memory_id;
  29
  30 class DiscardableMemoryImpl : public base::DiscardableMemory {
  31  public:
  32   DiscardableMemoryImpl(ChildDiscardableSharedMemoryManager* manager,
  33                         scoped_ptr<DiscardableSharedMemoryHeap::Span> span)
  34       : manager_(manager), span_(span.Pass()), is_locked_(true) {}
  35
  36   ~DiscardableMemoryImpl() override {
  37     if (is_locked_)
  38       manager_->UnlockSpan(span_.get());
  39
  40     manager_->ReleaseSpan(span_.Pass());
  41   }
  42
  43   // Overridden from base::DiscardableMemory:
  44   bool Lock() override {
  45     DCHECK(!is_locked_);
  46
  47     if (!manager_->LockSpan(span_.get()))
  48       return false;
  49
  50     is_locked_ = true;
  51     return true;
  52   }
  53   void Unlock() override {
  54     DCHECK(is_locked_);
  55
  56     manager_->UnlockSpan(span_.get());
  57     is_locked_ = false;
  58   }
  59   void* data() const override {
  60     DCHECK(is_locked_);
  61     return reinterpret_cast<void*>(span_->start() * base::GetPageSize());
  62   }
  63
  64  private:
  65   ChildDiscardableSharedMemoryManager* const manager_;
  66   scoped_ptr<DiscardableSharedMemoryHeap::Span> span_;
  67   bool is_locked_;
  68
  69   DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryImpl);
  70 };
  71
  72 void SendDeletedDiscardableSharedMemoryMessage(
  73     scoped_refptr<ThreadSafeSender> sender,
  74     DiscardableSharedMemoryId id) {
  75   sender->Send(new ChildProcessHostMsg_DeletedDiscardableSharedMemory(id));
  76 }
  77
  78 }  // namespace
  79
  80 ChildDiscardableSharedMemoryManager::ChildDiscardableSharedMemoryManager(
  81     ThreadSafeSender* sender)
  82     : heap_(base::GetPageSize()), sender_(sender) {
  83   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
  84       this, base::ThreadTaskRunnerHandle::Get());
  85 }
  86
  87 ChildDiscardableSharedMemoryManager::~ChildDiscardableSharedMemoryManager() {
  88   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
  89       this);
  90   // TODO(reveman): Determine if this DCHECK can be enabled. crbug.com/430533
  91   // DCHECK_EQ(heap_.GetSize(), heap_.GetSizeOfFreeLists());
  92   if (heap_.GetSize())
  93     MemoryUsageChanged(0, 0);
  94 }
  95
  96 scoped_ptr<base::DiscardableMemory>
  97 ChildDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(
  98     size_t size) {
  99   base::AutoLock lock(lock_);
 100
 101   DCHECK_NE(size, 0u);
 102
 103   UMA_HISTOGRAM_CUSTOM_COUNTS("Memory.DiscardableAllocationSize",
 104                               size / 1024,  // In KB
 105                               1,
 106                               4 * 1024 * 1024,  // 4 GB
 107                               50);
 108
 109   // Round up to multiple of page size.
 110   size_t pages = (size + base::GetPageSize() - 1) / base::GetPageSize();
 111
 112   // Default allocation size in pages.
 113   size_t allocation_pages = kAllocationSize / base::GetPageSize();
 114
 115   size_t slack = 0;
 116   // When searching the free lists, allow a slack between required size and
 117   // free span size that is less or equal to kAllocationSize. This is to
 118   // avoid segments larger then kAllocationSize unless they are a perfect
 119   // fit. The result is that large allocations can be reused without reducing
 120   // the ability to discard memory.
 121   if (pages < allocation_pages)
 122     slack = allocation_pages - pages;
 123
 124   size_t heap_size_prior_to_releasing_purged_memory = heap_.GetSize();
 125   for (;;) {
 126     // Search free lists for suitable span.
 127     scoped_ptr<DiscardableSharedMemoryHeap::Span> free_span =
 128         heap_.SearchFreeLists(pages, slack);
 129     if (!free_span.get())
 130       break;
 131
 132     // Attempt to lock |free_span|. Delete span and search free lists again
 133     // if locking failed.
 134     if (free_span->shared_memory()->Lock(
 135             free_span->start() * base::GetPageSize() -
 136                 reinterpret_cast<size_t>(free_span->shared_memory()->memory()),
 137             free_span->length() * base::GetPageSize()) ==
 138         base::DiscardableSharedMemory::FAILED) {
 139       DCHECK(!free_span->shared_memory()->IsMemoryResident());
 140       // We have to release purged memory before |free_span| can be destroyed.
 141       heap_.ReleasePurgedMemory();
 142       DCHECK(!free_span->shared_memory());
 143       continue;
 144     }
 145
 146     // Memory usage is guaranteed to have changed after having removed
 147     // at least one span from the free lists.
 148     MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 149
 150     return make_scoped_ptr(new DiscardableMemoryImpl(this, free_span.Pass()));
 151   }
 152
 153   // Release purged memory to free up the address space before we attempt to
 154   // allocate more memory.
 155   heap_.ReleasePurgedMemory();
 156
 157   // Make sure crash keys are up to date in case allocation fails.
 158   if (heap_.GetSize() != heap_size_prior_to_releasing_purged_memory)
 159     MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 160
 161   size_t pages_to_allocate =
 162       std::max(kAllocationSize / base::GetPageSize(), pages);
 163   size_t allocation_size_in_bytes = pages_to_allocate * base::GetPageSize();
 164
 165   DiscardableSharedMemoryId new_id =
 166       g_next_discardable_shared_memory_id.GetNext();
 167
 168   // Ask parent process to allocate a new discardable shared memory segment.
 169   scoped_ptr<base::DiscardableSharedMemory> shared_memory(
 170       AllocateLockedDiscardableSharedMemory(allocation_size_in_bytes, new_id));
 171
 172   // Create span for allocated memory.
 173   scoped_ptr<DiscardableSharedMemoryHeap::Span> new_span(heap_.Grow(
 174       shared_memory.Pass(), allocation_size_in_bytes, new_id,
 175       base::Bind(&SendDeletedDiscardableSharedMemoryMessage, sender_, new_id)));
 176
 177   // Unlock and insert any left over memory into free lists.
 178   if (pages < pages_to_allocate) {
 179     scoped_ptr<DiscardableSharedMemoryHeap::Span> leftover =
 180         heap_.Split(new_span.get(), pages);
 181     leftover->shared_memory()->Unlock(
 182         leftover->start() * base::GetPageSize() -
 183             reinterpret_cast<size_t>(leftover->shared_memory()->memory()),
 184         leftover->length() * base::GetPageSize());
 185     heap_.MergeIntoFreeLists(leftover.Pass());
 186   }
 187
 188   MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 189
 190   return make_scoped_ptr(new DiscardableMemoryImpl(this, new_span.Pass()));
 191 }
 192
 193 bool ChildDiscardableSharedMemoryManager::OnMemoryDump(
 194     base::trace_event::ProcessMemoryDump* pmd) {
 195   base::AutoLock lock(lock_);
 196   return heap_.OnMemoryDump(pmd);
 197 }
 198
 199 void ChildDiscardableSharedMemoryManager::ReleaseFreeMemory() {
 200   base::AutoLock lock(lock_);
 201
 202   size_t heap_size_prior_to_releasing_memory = heap_.GetSize();
 203
 204   // Release both purged and free memory.
 205   heap_.ReleasePurgedMemory();
 206   heap_.ReleaseFreeMemory();
 207
 208   if (heap_.GetSize() != heap_size_prior_to_releasing_memory)
 209     MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 210 }
 211
 212 bool ChildDiscardableSharedMemoryManager::LockSpan(
 213     DiscardableSharedMemoryHeap::Span* span) {
 214   base::AutoLock lock(lock_);
 215
 216   if (!span->shared_memory())
 217     return false;
 218
 219   size_t offset = span->start() * base::GetPageSize() -
 220       reinterpret_cast<size_t>(span->shared_memory()->memory());
 221   size_t length = span->length() * base::GetPageSize();
 222
 223   switch (span->shared_memory()->Lock(offset, length)) {
 224     case base::DiscardableSharedMemory::SUCCESS:
 225       return true;
 226     case base::DiscardableSharedMemory::PURGED:
 227       span->shared_memory()->Unlock(offset, length);
 228       return false;
 229     case base::DiscardableSharedMemory::FAILED:
 230       return false;
 231   }
 232
 233   NOTREACHED();
 234   return false;
 235 }
 236
 237 void ChildDiscardableSharedMemoryManager::UnlockSpan(
 238     DiscardableSharedMemoryHeap::Span* span) {
 239   base::AutoLock lock(lock_);
 240
 241   DCHECK(span->shared_memory());
 242   size_t offset = span->start() * base::GetPageSize() -
 243       reinterpret_cast<size_t>(span->shared_memory()->memory());
 244   size_t length = span->length() * base::GetPageSize();
 245
 246   return span->shared_memory()->Unlock(offset, length);
 247 }
 248
 249 void ChildDiscardableSharedMemoryManager::ReleaseSpan(
 250     scoped_ptr<DiscardableSharedMemoryHeap::Span> span) {
 251   base::AutoLock lock(lock_);
 252
 253   // Delete span instead of merging it into free lists if memory is gone.
 254   if (!span->shared_memory())
 255     return;
 256
 257   heap_.MergeIntoFreeLists(span.Pass());
 258
 259   // Bytes of free memory changed.
 260   MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 261 }
 262
 263 scoped_ptr<base::DiscardableSharedMemory>
 264 ChildDiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
 265     size_t size,
 266     DiscardableSharedMemoryId id) {
 267   TRACE_EVENT2("renderer",
 268                "ChildDiscardableSharedMemoryManager::"
 269                "AllocateLockedDiscardableSharedMemory",
 270                "size", size, "id", id);
 271
 272   base::SharedMemoryHandle handle = base::SharedMemory::NULLHandle();
 273   sender_->Send(
 274       new ChildProcessHostMsg_SyncAllocateLockedDiscardableSharedMemory(
 275           size, id, &handle));
 276   scoped_ptr<base::DiscardableSharedMemory> memory(
 277       new base::DiscardableSharedMemory(handle));
 278   if (!memory->Map(size))
 279     base::TerminateBecauseOutOfMemory(size);
 280   return memory.Pass();
 281 }
 282
 283 void ChildDiscardableSharedMemoryManager::MemoryUsageChanged(
 284     size_t new_bytes_total,
 285     size_t new_bytes_free) const {
 286   TRACE_COUNTER2("renderer", "DiscardableMemoryUsage", "allocated",
 287                  new_bytes_total - new_bytes_free, "free", new_bytes_free);
 288
 289   static const char kDiscardableMemoryAllocatedKey[] =
 290       "discardable-memory-allocated";
 291   base::debug::SetCrashKeyValue(kDiscardableMemoryAllocatedKey,
 292                                 base::Uint64ToString(new_bytes_total));
 293
 294   static const char kDiscardableMemoryFreeKey[] = "discardable-memory-free";
 295   base::debug::SetCrashKeyValue(kDiscardableMemoryFreeKey,
 296                                 base::Uint64ToString(new_bytes_free));
 297 }
 298
 299 }  // namespace content