1 // Copyright (c) 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.h"
6
7 #include <mach/mach.h>
8
9 #include "base/basictypes.h"
10 #include "base/compiler_specific.h"
11 #include "base/lazy_instance.h"
12 #include "base/logging.h"
13 #include "base/mac/mach_logging.h"
14 #include "base/mac/scoped_mach_vm.h"
15 #include "base/memory/discardable_memory_emulated.h"
16 #include "base/memory/discardable_memory_malloc.h"
17 #include "base/memory/discardable_memory_manager.h"
18 #include "base/memory/scoped_ptr.h"
19
20 namespace base {
21 namespace {
22
23 // For Mac, have the DiscardableMemoryManager trigger userspace eviction when
24 // address space usage gets too high (e.g. 512 MBytes).
25 const size_t kMacMemoryLimit = 512 * 1024 * 1024;
26
27 struct SharedState {
SharedStatebase::__anondbb1c90b0111::SharedState28 SharedState()
29 : manager(kMacMemoryLimit,
30 kMacMemoryLimit,
31 kMacMemoryLimit,
32 TimeDelta::Max()) {}
33
34 internal::DiscardableMemoryManager manager;
35 };
36 LazyInstance<SharedState>::Leaky g_shared_state = LAZY_INSTANCE_INITIALIZER;
37
38 // The VM subsystem allows tagging of memory and 240-255 is reserved for
39 // application use (see mach/vm_statistics.h). Pick 252 (after chromium's atomic
40 // weight of ~52).
41 const int kDiscardableMemoryTag = VM_MAKE_TAG(252);
42
43 class DiscardableMemoryMac
44 : public DiscardableMemory,
45 public internal::DiscardableMemoryManagerAllocation {
46 public:
DiscardableMemoryMac(size_t bytes)47 explicit DiscardableMemoryMac(size_t bytes)
48 : memory_(0, 0),
49 bytes_(mach_vm_round_page(bytes)),
50 is_locked_(false) {
51 g_shared_state.Pointer()->manager.Register(this, bytes);
52 }
53
Initialize()54 bool Initialize() { return Lock() != DISCARDABLE_MEMORY_LOCK_STATUS_FAILED; }
55
~DiscardableMemoryMac()56 virtual ~DiscardableMemoryMac() {
57 if (is_locked_)
58 Unlock();
59 g_shared_state.Pointer()->manager.Unregister(this);
60 }
61
62 // Overridden from DiscardableMemory:
Lock()63 virtual DiscardableMemoryLockStatus Lock() OVERRIDE {
64 DCHECK(!is_locked_);
65
66 bool purged = false;
67 if (!g_shared_state.Pointer()->manager.AcquireLock(this, &purged))
68 return DISCARDABLE_MEMORY_LOCK_STATUS_FAILED;
69
70 is_locked_ = true;
71 return purged ? DISCARDABLE_MEMORY_LOCK_STATUS_PURGED
72 : DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS;
73 }
74
Unlock()75 virtual void Unlock() OVERRIDE {
76 DCHECK(is_locked_);
77 g_shared_state.Pointer()->manager.ReleaseLock(this);
78 is_locked_ = false;
79 }
80
Memory() const81 virtual void* Memory() const OVERRIDE {
82 DCHECK(is_locked_);
83 return reinterpret_cast<void*>(memory_.address());
84 }
85
86 // Overridden from internal::DiscardableMemoryManagerAllocation:
AllocateAndAcquireLock()87 virtual bool AllocateAndAcquireLock() OVERRIDE {
88 kern_return_t ret;
89 bool persistent;
90 if (!memory_.size()) {
91 vm_address_t address = 0;
92 ret = vm_allocate(
93 mach_task_self(),
94 &address,
95 bytes_,
96 VM_FLAGS_ANYWHERE | VM_FLAGS_PURGABLE | kDiscardableMemoryTag);
97 MACH_CHECK(ret == KERN_SUCCESS, ret) << "vm_allocate";
98 memory_.reset(address, bytes_);
99
100 // When making a fresh allocation, it's impossible for |persistent| to
101 // be true.
102 persistent = false;
103 } else {
104 // |persistent| will be reset to false below if appropriate, but when
105 // reusing an existing allocation, it's possible for it to be true.
106 persistent = true;
107
108 #if !defined(NDEBUG)
109 ret = vm_protect(mach_task_self(),
110 memory_.address(),
111 memory_.size(),
112 FALSE,
113 VM_PROT_DEFAULT);
114 MACH_DCHECK(ret == KERN_SUCCESS, ret) << "vm_protect";
115 #endif
116 }
117
118 int state = VM_PURGABLE_NONVOLATILE;
119 ret = vm_purgable_control(mach_task_self(),
120 memory_.address(),
121 VM_PURGABLE_SET_STATE,
122 &state);
123 MACH_CHECK(ret == KERN_SUCCESS, ret) << "vm_purgable_control";
124 if (state & VM_PURGABLE_EMPTY)
125 persistent = false;
126
127 return persistent;
128 }
129
ReleaseLock()130 virtual void ReleaseLock() OVERRIDE {
131 int state = VM_PURGABLE_VOLATILE | VM_VOLATILE_GROUP_DEFAULT;
132 kern_return_t ret = vm_purgable_control(mach_task_self(),
133 memory_.address(),
134 VM_PURGABLE_SET_STATE,
135 &state);
136 MACH_CHECK(ret == KERN_SUCCESS, ret) << "vm_purgable_control";
137
138 #if !defined(NDEBUG)
139 ret = vm_protect(mach_task_self(),
140 memory_.address(),
141 memory_.size(),
142 FALSE,
143 VM_PROT_NONE);
144 MACH_DCHECK(ret == KERN_SUCCESS, ret) << "vm_protect";
145 #endif
146 }
147
Purge()148 virtual void Purge() OVERRIDE {
149 memory_.reset();
150 }
151
152 private:
153 mac::ScopedMachVM memory_;
154 const size_t bytes_;
155 bool is_locked_;
156
157 DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryMac);
158 };
159
160 } // namespace
161
162 // static
RegisterMemoryPressureListeners()163 void DiscardableMemory::RegisterMemoryPressureListeners() {
164 internal::DiscardableMemoryEmulated::RegisterMemoryPressureListeners();
165 }
166
167 // static
UnregisterMemoryPressureListeners()168 void DiscardableMemory::UnregisterMemoryPressureListeners() {
169 internal::DiscardableMemoryEmulated::UnregisterMemoryPressureListeners();
170 }
171
172 // static
ReduceMemoryUsage()173 bool DiscardableMemory::ReduceMemoryUsage() {
174 return internal::DiscardableMemoryEmulated::ReduceMemoryUsage();
175 }
176
177 // static
GetSupportedTypes(std::vector<DiscardableMemoryType> * types)178 void DiscardableMemory::GetSupportedTypes(
179 std::vector<DiscardableMemoryType>* types) {
180 const DiscardableMemoryType supported_types[] = {
181 DISCARDABLE_MEMORY_TYPE_MAC,
182 DISCARDABLE_MEMORY_TYPE_EMULATED,
183 DISCARDABLE_MEMORY_TYPE_MALLOC
184 };
185 types->assign(supported_types, supported_types + arraysize(supported_types));
186 }
187
188 // static
CreateLockedMemoryWithType(DiscardableMemoryType type,size_t size)189 scoped_ptr<DiscardableMemory> DiscardableMemory::CreateLockedMemoryWithType(
190 DiscardableMemoryType type, size_t size) {
191 switch (type) {
192 case DISCARDABLE_MEMORY_TYPE_NONE:
193 case DISCARDABLE_MEMORY_TYPE_ASHMEM:
194 return scoped_ptr<DiscardableMemory>();
195 case DISCARDABLE_MEMORY_TYPE_MAC: {
196 scoped_ptr<DiscardableMemoryMac> memory(new DiscardableMemoryMac(size));
197 if (!memory->Initialize())
198 return scoped_ptr<DiscardableMemory>();
199
200 return memory.PassAs<DiscardableMemory>();
201 }
202 case DISCARDABLE_MEMORY_TYPE_EMULATED: {
203 scoped_ptr<internal::DiscardableMemoryEmulated> memory(
204 new internal::DiscardableMemoryEmulated(size));
205 if (!memory->Initialize())
206 return scoped_ptr<DiscardableMemory>();
207
208 return memory.PassAs<DiscardableMemory>();
209 }
210 case DISCARDABLE_MEMORY_TYPE_MALLOC: {
211 scoped_ptr<internal::DiscardableMemoryMalloc> memory(
212 new internal::DiscardableMemoryMalloc(size));
213 if (!memory->Initialize())
214 return scoped_ptr<DiscardableMemory>();
215
216 return memory.PassAs<DiscardableMemory>();
217 }
218 }
219
220 NOTREACHED();
221 return scoped_ptr<DiscardableMemory>();
222 }
223
224 // static
PurgeForTesting()225 void DiscardableMemory::PurgeForTesting() {
226 int state = 0;
227 vm_purgable_control(mach_task_self(), 0, VM_PURGABLE_PURGE_ALL, &state);
228 internal::DiscardableMemoryEmulated::PurgeForTesting();
229 }
230
231 } // namespace base
232