base/memory/discardable_memory_emulated.cc

   1 // Copyright 2013 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_emulated.h"
   6
   7 #include "base/lazy_instance.h"
   8 #include "base/memory/discardable_memory_manager.h"
   9
  10 namespace base {
  11 namespace {
  12
  13 // This is admittedly pretty magical.
  14 const size_t kEmulatedMemoryLimit = 512 * 1024 * 1024;
  15 const size_t kEmulatedSoftMemoryLimit = 32 * 1024 * 1024;
  16 const size_t kEmulatedHardMemoryLimitExpirationTimeMs = 1000;
  17
  18 // internal::DiscardableMemoryManager has an explicit constructor that takes
  19 // a number of memory limit parameters. The LeakyLazyInstanceTraits doesn't
  20 // handle the case. Thus, we need our own class here.
  21 struct DiscardableMemoryManagerLazyInstanceTraits {
  22   // Leaky as discardable memory clients can use this after the exit handler
  23   // has been called.
  24   static const bool kRegisterOnExit = false;
  25 #ifndef NDEBUG
  26   static const bool kAllowedToAccessOnNonjoinableThread = true;
  27 #endif
  28
  29   static internal::DiscardableMemoryManager* New(void* instance) {
  30     return new (instance) internal::DiscardableMemoryManager(
  31         kEmulatedMemoryLimit,
  32         kEmulatedSoftMemoryLimit,
  33         TimeDelta::FromMilliseconds(kEmulatedHardMemoryLimitExpirationTimeMs));
  34   }
  35   static void Delete(internal::DiscardableMemoryManager* instance) {
  36     instance->~DiscardableMemoryManager();
  37   }
  38 };
  39
  40 LazyInstance<internal::DiscardableMemoryManager,
  41              DiscardableMemoryManagerLazyInstanceTraits>
  42     g_manager = LAZY_INSTANCE_INITIALIZER;
  43
  44 }  // namespace
  45
  46 namespace internal {
  47
  48 DiscardableMemoryEmulated::DiscardableMemoryEmulated(size_t bytes)
  49     : bytes_(bytes),
  50       is_locked_(false) {
  51   g_manager.Pointer()->Register(this, bytes);
  52 }
  53
  54 DiscardableMemoryEmulated::~DiscardableMemoryEmulated() {
  55   if (is_locked_)
  56     Unlock();
  57   g_manager.Pointer()->Unregister(this);
  58 }
  59
  60 // static
  61 bool DiscardableMemoryEmulated::ReduceMemoryUsage() {
  62   return g_manager.Pointer()->ReduceMemoryUsage();
  63 }
  64
  65 // static
  66 void DiscardableMemoryEmulated::ReduceMemoryUsageUntilWithinLimit(
  67     size_t bytes) {
  68   g_manager.Pointer()->ReduceMemoryUsageUntilWithinLimit(bytes);
  69 }
  70
  71 // static
  72 void DiscardableMemoryEmulated::PurgeForTesting() {
  73   g_manager.Pointer()->PurgeAll();
  74 }
  75
  76 bool DiscardableMemoryEmulated::Initialize() {
  77   return Lock() != DISCARDABLE_MEMORY_LOCK_STATUS_FAILED;
  78 }
  79
  80 DiscardableMemoryLockStatus DiscardableMemoryEmulated::Lock() {
  81   DCHECK(!is_locked_);
  82
  83   bool purged = false;
  84   if (!g_manager.Pointer()->AcquireLock(this, &purged))
  85     return DISCARDABLE_MEMORY_LOCK_STATUS_FAILED;
  86
  87   is_locked_ = true;
  88   return purged ? DISCARDABLE_MEMORY_LOCK_STATUS_PURGED
  89                 : DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS;
  90 }
  91
  92 void DiscardableMemoryEmulated::Unlock() {
  93   DCHECK(is_locked_);
  94   g_manager.Pointer()->ReleaseLock(this);
  95   is_locked_ = false;
  96 }
  97
  98 void* DiscardableMemoryEmulated::Memory() const {
  99   DCHECK(is_locked_);
 100   DCHECK(memory_);
 101   return memory_.get();
 102 }
 103
 104 bool DiscardableMemoryEmulated::AllocateAndAcquireLock() {
 105   if (memory_)
 106     return true;
 107
 108   memory_.reset(new uint8[bytes_]);
 109   return false;
 110 }
 111
 112 void DiscardableMemoryEmulated::Purge() {
 113   memory_.reset();
 114 }
 115
 116 bool DiscardableMemoryEmulated::IsMemoryResident() const {
 117   return true;
 118 }
 119
 120 }  // namespace internal
 121 }  // namespace base