base/memory/discardable_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 "base/memory/discardable_memory_manager.h"
   6
   7 #include "base/bind.h"
   8 #include "base/containers/hash_tables.h"
   9 #include "base/containers/mru_cache.h"
  10 #include "base/debug/trace_event.h"
  11 #include "base/synchronization/lock.h"
  12 #include "base/sys_info.h"
  13
  14 namespace base {
  15 namespace internal {
  16
  17 namespace {
  18
  19 // This is admittedly pretty magical. It's approximately enough memory for four
  20 // 2560x1600 images.
  21 static const size_t kDefaultDiscardableMemoryLimit = 64 * 1024 * 1024;
  22 static const size_t kDefaultBytesToKeepUnderModeratePressure =
  23     kDefaultDiscardableMemoryLimit / 4;
  24
  25 }  // namespace
  26
  27 DiscardableMemoryManager::DiscardableMemoryManager()
  28     : allocations_(AllocationMap::NO_AUTO_EVICT),
  29       bytes_allocated_(0),
  30       discardable_memory_limit_(kDefaultDiscardableMemoryLimit),
  31       bytes_to_keep_under_moderate_pressure_(
  32           kDefaultBytesToKeepUnderModeratePressure) {
  33   BytesAllocatedChanged();
  34 }
  35
  36 DiscardableMemoryManager::~DiscardableMemoryManager() {
  37   DCHECK(allocations_.empty());
  38   DCHECK_EQ(0u, bytes_allocated_);
  39 }
  40
  41 void DiscardableMemoryManager::RegisterMemoryPressureListener() {
  42   AutoLock lock(lock_);
  43   DCHECK(base::MessageLoop::current());
  44   DCHECK(!memory_pressure_listener_);
  45   memory_pressure_listener_.reset(
  46       new MemoryPressureListener(
  47           base::Bind(&DiscardableMemoryManager::OnMemoryPressure,
  48                      Unretained(this))));
  49 }
  50
  51 void DiscardableMemoryManager::UnregisterMemoryPressureListener() {
  52   AutoLock lock(lock_);
  53   DCHECK(memory_pressure_listener_);
  54   memory_pressure_listener_.reset();
  55 }
  56
  57 void DiscardableMemoryManager::SetDiscardableMemoryLimit(size_t bytes) {
  58   AutoLock lock(lock_);
  59   discardable_memory_limit_ = bytes;
  60   EnforcePolicyWithLockAcquired();
  61 }
  62
  63 void DiscardableMemoryManager::SetBytesToKeepUnderModeratePressure(
  64     size_t bytes) {
  65   AutoLock lock(lock_);
  66   bytes_to_keep_under_moderate_pressure_ = bytes;
  67 }
  68
  69 void DiscardableMemoryManager::Register(
  70     const DiscardableMemory* discardable, size_t bytes) {
  71   AutoLock lock(lock_);
  72   // A registered memory listener is currently required. This DCHECK can be
  73   // moved or removed if we decide that it's useful to relax this condition.
  74   // TODO(reveman): Enable this DCHECK when skia and blink are able to
  75   // register memory pressure listeners. crbug.com/333907
  76   // DCHECK(memory_pressure_listener_);
  77   DCHECK(allocations_.Peek(discardable) == allocations_.end());
  78   allocations_.Put(discardable, Allocation(bytes));
  79 }
  80
  81 void DiscardableMemoryManager::Unregister(
  82     const DiscardableMemory* discardable) {
  83   AutoLock lock(lock_);
  84   AllocationMap::iterator it = allocations_.Peek(discardable);
  85   if (it == allocations_.end())
  86     return;
  87
  88   if (it->second.memory) {
  89     size_t bytes = it->second.bytes;
  90     DCHECK_LE(bytes, bytes_allocated_);
  91     bytes_allocated_ -= bytes;
  92     BytesAllocatedChanged();
  93     free(it->second.memory);
  94   }
  95   allocations_.Erase(it);
  96 }
  97
  98 scoped_ptr<uint8, FreeDeleter> DiscardableMemoryManager::Acquire(
  99     const DiscardableMemory* discardable,
 100     bool* purged) {
 101   AutoLock lock(lock_);
 102   // NB: |allocations_| is an MRU cache, and use of |Get| here updates that
 103   // cache.
 104   AllocationMap::iterator it = allocations_.Get(discardable);
 105   CHECK(it != allocations_.end());
 106
 107   if (it->second.memory) {
 108     scoped_ptr<uint8, FreeDeleter> memory(it->second.memory);
 109     it->second.memory = NULL;
 110     *purged = false;
 111     return memory.Pass();
 112   }
 113
 114   size_t bytes = it->second.bytes;
 115   if (!bytes)
 116     return scoped_ptr<uint8, FreeDeleter>();
 117
 118   if (discardable_memory_limit_) {
 119     size_t limit = 0;
 120     if (bytes < discardable_memory_limit_)
 121       limit = discardable_memory_limit_ - bytes;
 122
 123     PurgeLRUWithLockAcquiredUntilUsageIsWithin(limit);
 124   }
 125
 126   // Check for overflow.
 127   if (std::numeric_limits<size_t>::max() - bytes < bytes_allocated_)
 128     return scoped_ptr<uint8, FreeDeleter>();
 129
 130   scoped_ptr<uint8, FreeDeleter> memory(static_cast<uint8*>(malloc(bytes)));
 131   if (!memory)
 132     return scoped_ptr<uint8, FreeDeleter>();
 133
 134   bytes_allocated_ += bytes;
 135   BytesAllocatedChanged();
 136
 137   *purged = true;
 138   return memory.Pass();
 139 }
 140
 141 void DiscardableMemoryManager::Release(
 142     const DiscardableMemory* discardable,
 143     scoped_ptr<uint8, FreeDeleter> memory) {
 144   AutoLock lock(lock_);
 145   // NB: |allocations_| is an MRU cache, and use of |Get| here updates that
 146   // cache.
 147   AllocationMap::iterator it = allocations_.Get(discardable);
 148   CHECK(it != allocations_.end());
 149
 150   DCHECK(!it->second.memory);
 151   it->second.memory = memory.release();
 152
 153   EnforcePolicyWithLockAcquired();
 154 }
 155
 156 void DiscardableMemoryManager::PurgeAll() {
 157   AutoLock lock(lock_);
 158   PurgeLRUWithLockAcquiredUntilUsageIsWithin(0);
 159 }
 160
 161 bool DiscardableMemoryManager::IsRegisteredForTest(
 162     const DiscardableMemory* discardable) const {
 163   AutoLock lock(lock_);
 164   AllocationMap::const_iterator it = allocations_.Peek(discardable);
 165   return it != allocations_.end();
 166 }
 167
 168 bool DiscardableMemoryManager::CanBePurgedForTest(
 169     const DiscardableMemory* discardable) const {
 170   AutoLock lock(lock_);
 171   AllocationMap::const_iterator it = allocations_.Peek(discardable);
 172   return it != allocations_.end() && it->second.memory;
 173 }
 174
 175 size_t DiscardableMemoryManager::GetBytesAllocatedForTest() const {
 176   AutoLock lock(lock_);
 177   return bytes_allocated_;
 178 }
 179
 180 void DiscardableMemoryManager::OnMemoryPressure(
 181     MemoryPressureListener::MemoryPressureLevel pressure_level) {
 182   switch (pressure_level) {
 183     case MemoryPressureListener::MEMORY_PRESSURE_MODERATE:
 184       Purge();
 185       return;
 186     case MemoryPressureListener::MEMORY_PRESSURE_CRITICAL:
 187       PurgeAll();
 188       return;
 189   }
 190
 191   NOTREACHED();
 192 }
 193
 194 void DiscardableMemoryManager::Purge() {
 195   AutoLock lock(lock_);
 196
 197   PurgeLRUWithLockAcquiredUntilUsageIsWithin(
 198       bytes_to_keep_under_moderate_pressure_);
 199 }
 200
 201 void DiscardableMemoryManager::PurgeLRUWithLockAcquiredUntilUsageIsWithin(
 202     size_t limit) {
 203   TRACE_EVENT1(
 204       "base",
 205       "DiscardableMemoryManager::PurgeLRUWithLockAcquiredUntilUsageIsWithin",
 206       "limit", limit);
 207
 208   lock_.AssertAcquired();
 209
 210   size_t bytes_allocated_before_purging = bytes_allocated_;
 211   for (AllocationMap::reverse_iterator it = allocations_.rbegin();
 212        it != allocations_.rend();
 213        ++it) {
 214     if (bytes_allocated_ <= limit)
 215       break;
 216     if (!it->second.memory)
 217       continue;
 218
 219     size_t bytes = it->second.bytes;
 220     DCHECK_LE(bytes, bytes_allocated_);
 221     bytes_allocated_ -= bytes;
 222     free(it->second.memory);
 223     it->second.memory = NULL;
 224   }
 225
 226   if (bytes_allocated_ != bytes_allocated_before_purging)
 227     BytesAllocatedChanged();
 228 }
 229
 230 void DiscardableMemoryManager::EnforcePolicyWithLockAcquired() {
 231   PurgeLRUWithLockAcquiredUntilUsageIsWithin(discardable_memory_limit_);
 232 }
 233
 234 void DiscardableMemoryManager::BytesAllocatedChanged() const {
 235   TRACE_COUNTER_ID1("base",
 236                     "DiscardableMemoryUsage",
 237                     this,
 238                     bytes_allocated_);
 239 }
 240
 241 }  // namespace internal
 242 }  // namespace base