OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/discardable_memory/client/client_discardable_shared_memory_
manager.h" | 5 #include "components/discardable_memory/client/client_discardable_shared_memory_
manager.h" |
6 | 6 |
7 #include <inttypes.h> | 7 #include <inttypes.h> |
8 | 8 |
9 #include <algorithm> | 9 #include <algorithm> |
10 #include <utility> | 10 #include <utility> |
11 | 11 |
12 #include "base/atomic_sequence_num.h" | 12 #include "base/atomic_sequence_num.h" |
13 #include "base/bind.h" | 13 #include "base/bind.h" |
14 #include "base/debug/crash_logging.h" | 14 #include "base/debug/crash_logging.h" |
15 #include "base/macros.h" | 15 #include "base/macros.h" |
16 #include "base/memory/discardable_memory.h" | 16 #include "base/memory/discardable_memory.h" |
17 #include "base/memory/discardable_shared_memory.h" | 17 #include "base/memory/discardable_shared_memory.h" |
18 #include "base/memory/ptr_util.h" | 18 #include "base/memory/ptr_util.h" |
19 #include "base/metrics/histogram_macros.h" | 19 #include "base/metrics/histogram_macros.h" |
20 #include "base/process/memory.h" | 20 #include "base/process/memory.h" |
21 #include "base/process/process_metrics.h" | 21 #include "base/process/process_metrics.h" |
22 #include "base/strings/string_number_conversions.h" | 22 #include "base/strings/string_number_conversions.h" |
23 #include "base/strings/stringprintf.h" | 23 #include "base/strings/stringprintf.h" |
| 24 #include "base/synchronization/waitable_event.h" |
24 #include "base/threading/thread_task_runner_handle.h" | 25 #include "base/threading/thread_task_runner_handle.h" |
25 #include "base/trace_event/memory_dump_manager.h" | 26 #include "base/trace_event/memory_dump_manager.h" |
26 #include "base/trace_event/trace_event.h" | 27 #include "base/trace_event/trace_event.h" |
| 28 #include "mojo/public/cpp/system/platform_handle.h" |
27 | 29 |
28 namespace discardable_memory { | 30 namespace discardable_memory { |
29 namespace { | 31 namespace { |
30 | 32 |
31 // Default allocation size. | 33 // Default allocation size. |
32 const size_t kAllocationSize = 4 * 1024 * 1024; | 34 const size_t kAllocationSize = 4 * 1024 * 1024; |
33 | 35 |
34 // Global atomic to generate unique discardable shared memory IDs. | 36 // Global atomic to generate unique discardable shared memory IDs. |
35 base::StaticAtomicSequenceNumber g_next_discardable_shared_memory_id; | 37 base::StaticAtomicSequenceNumber g_next_discardable_shared_memory_id; |
36 | 38 |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
75 } | 77 } |
76 | 78 |
77 private: | 79 private: |
78 ClientDiscardableSharedMemoryManager* const manager_; | 80 ClientDiscardableSharedMemoryManager* const manager_; |
79 std::unique_ptr<DiscardableSharedMemoryHeap::Span> span_; | 81 std::unique_ptr<DiscardableSharedMemoryHeap::Span> span_; |
80 bool is_locked_; | 82 bool is_locked_; |
81 | 83 |
82 DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryImpl); | 84 DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryImpl); |
83 }; | 85 }; |
84 | 86 |
85 void SendDeletedDiscardableSharedMemoryMessage( | 87 void InitManagerMojoOnIO(mojom::DiscardableSharedMemoryManagerPtr* manager_mojo, |
86 ClientDiscardableSharedMemoryManager::Delegate* delegate, | 88 mojom::DiscardableSharedMemoryManagerPtrInfo info) { |
87 DiscardableSharedMemoryId id) { | 89 manager_mojo->Bind(std::move(info)); |
88 delegate->DeletedDiscardableSharedMemory(id); | 90 } |
| 91 |
| 92 void DeletedDiscardableSharedMemoryOnIO( |
| 93 mojom::DiscardableSharedMemoryManagerPtr* manager_mojo, |
| 94 int32_t id) { |
| 95 (*manager_mojo)->DeletedDiscardableSharedMemory(id); |
89 } | 96 } |
90 | 97 |
91 } // namespace | 98 } // namespace |
92 | 99 |
93 ClientDiscardableSharedMemoryManager::ClientDiscardableSharedMemoryManager( | 100 ClientDiscardableSharedMemoryManager::ClientDiscardableSharedMemoryManager( |
94 Delegate* delegate) | 101 mojom::DiscardableSharedMemoryManagerPtr manager, |
95 : heap_(base::GetPageSize()), delegate_(delegate) { | 102 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner) |
| 103 : io_task_runner_(std::move(io_task_runner)), |
| 104 manager_mojo_(new mojom::DiscardableSharedMemoryManagerPtr), |
| 105 heap_(new DiscardableSharedMemoryHeap(base::GetPageSize())) { |
96 base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( | 106 base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( |
97 this, "ClientDiscardableSharedMemoryManager", | 107 this, "ClientDiscardableSharedMemoryManager", |
98 base::ThreadTaskRunnerHandle::Get()); | 108 base::ThreadTaskRunnerHandle::Get()); |
| 109 mojom::DiscardableSharedMemoryManagerPtrInfo info = manager.PassInterface(); |
| 110 io_task_runner_->PostTask( |
| 111 FROM_HERE, base::Bind(&InitManagerMojoOnIO, manager_mojo_.get(), |
| 112 base::Passed(&info))); |
99 } | 113 } |
100 | 114 |
101 ClientDiscardableSharedMemoryManager::~ClientDiscardableSharedMemoryManager() { | 115 ClientDiscardableSharedMemoryManager::~ClientDiscardableSharedMemoryManager() { |
102 base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider( | 116 base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider( |
103 this); | 117 this); |
104 // TODO(reveman): Determine if this DCHECK can be enabled. crbug.com/430533 | 118 // TODO(reveman): Determine if this DCHECK can be enabled. crbug.com/430533 |
105 // DCHECK_EQ(heap_.GetSize(), heap_.GetSizeOfFreeLists()); | 119 // DCHECK_EQ(heap_->GetSize(), heap_->GetSizeOfFreeLists()); |
106 if (heap_.GetSize()) | 120 if (heap_->GetSize()) |
107 MemoryUsageChanged(0, 0); | 121 MemoryUsageChanged(0, 0); |
| 122 |
| 123 // Releasing the |heap_| before posting a task for deleting |manager_mojo_|. |
| 124 // It is because releasing |heap_| will invoke DeletedDiscardableSharedMemory |
| 125 // which needs |manager_mojo_|. |
| 126 heap_.reset(); |
| 127 |
| 128 // Delete the |manager_mojo_| on IO thread, so any pending tasks on IO thread |
| 129 // will be executed before the |manager_mojo_| is deleted. |
| 130 bool posted = io_task_runner_->DeleteSoon(FROM_HERE, manager_mojo_.release()); |
| 131 DCHECK(posted); |
108 } | 132 } |
109 | 133 |
110 std::unique_ptr<base::DiscardableMemory> | 134 std::unique_ptr<base::DiscardableMemory> |
111 ClientDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory( | 135 ClientDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory( |
112 size_t size) { | 136 size_t size) { |
113 base::AutoLock lock(lock_); | 137 base::AutoLock lock(lock_); |
114 | 138 |
115 DCHECK_NE(size, 0u); | 139 DCHECK_NE(size, 0u); |
116 | 140 |
117 auto size_in_kb = static_cast<base::HistogramBase::Sample>(size / 1024); | 141 auto size_in_kb = static_cast<base::HistogramBase::Sample>(size / 1024); |
(...skipping 13 matching lines...) Expand all Loading... |
131 | 155 |
132 size_t slack = 0; | 156 size_t slack = 0; |
133 // When searching the free lists, allow a slack between required size and | 157 // When searching the free lists, allow a slack between required size and |
134 // free span size that is less or equal to kAllocationSize. This is to | 158 // free span size that is less or equal to kAllocationSize. This is to |
135 // avoid segments larger then kAllocationSize unless they are a perfect | 159 // avoid segments larger then kAllocationSize unless they are a perfect |
136 // fit. The result is that large allocations can be reused without reducing | 160 // fit. The result is that large allocations can be reused without reducing |
137 // the ability to discard memory. | 161 // the ability to discard memory. |
138 if (pages < allocation_pages) | 162 if (pages < allocation_pages) |
139 slack = allocation_pages - pages; | 163 slack = allocation_pages - pages; |
140 | 164 |
141 size_t heap_size_prior_to_releasing_purged_memory = heap_.GetSize(); | 165 size_t heap_size_prior_to_releasing_purged_memory = heap_->GetSize(); |
142 for (;;) { | 166 for (;;) { |
143 // Search free lists for suitable span. | 167 // Search free lists for suitable span. |
144 std::unique_ptr<DiscardableSharedMemoryHeap::Span> free_span = | 168 std::unique_ptr<DiscardableSharedMemoryHeap::Span> free_span = |
145 heap_.SearchFreeLists(pages, slack); | 169 heap_->SearchFreeLists(pages, slack); |
146 if (!free_span.get()) | 170 if (!free_span.get()) |
147 break; | 171 break; |
148 | 172 |
149 // Attempt to lock |free_span|. Delete span and search free lists again | 173 // Attempt to lock |free_span|. Delete span and search free lists again |
150 // if locking failed. | 174 // if locking failed. |
151 if (free_span->shared_memory()->Lock( | 175 if (free_span->shared_memory()->Lock( |
152 free_span->start() * base::GetPageSize() - | 176 free_span->start() * base::GetPageSize() - |
153 reinterpret_cast<size_t>(free_span->shared_memory()->memory()), | 177 reinterpret_cast<size_t>(free_span->shared_memory()->memory()), |
154 free_span->length() * base::GetPageSize()) == | 178 free_span->length() * base::GetPageSize()) == |
155 base::DiscardableSharedMemory::FAILED) { | 179 base::DiscardableSharedMemory::FAILED) { |
156 DCHECK(!free_span->shared_memory()->IsMemoryResident()); | 180 DCHECK(!free_span->shared_memory()->IsMemoryResident()); |
157 // We have to release purged memory before |free_span| can be destroyed. | 181 // We have to release purged memory before |free_span| can be destroyed. |
158 heap_.ReleasePurgedMemory(); | 182 heap_->ReleasePurgedMemory(); |
159 DCHECK(!free_span->shared_memory()); | 183 DCHECK(!free_span->shared_memory()); |
160 continue; | 184 continue; |
161 } | 185 } |
162 | 186 |
163 free_span->set_is_locked(true); | 187 free_span->set_is_locked(true); |
164 | 188 |
165 // Memory usage is guaranteed to have changed after having removed | 189 // Memory usage is guaranteed to have changed after having removed |
166 // at least one span from the free lists. | 190 // at least one span from the free lists. |
167 MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists()); | 191 MemoryUsageChanged(heap_->GetSize(), heap_->GetSizeOfFreeLists()); |
168 | 192 |
169 return base::MakeUnique<DiscardableMemoryImpl>(this, std::move(free_span)); | 193 return base::MakeUnique<DiscardableMemoryImpl>(this, std::move(free_span)); |
170 } | 194 } |
171 | 195 |
172 // Release purged memory to free up the address space before we attempt to | 196 // Release purged memory to free up the address space before we attempt to |
173 // allocate more memory. | 197 // allocate more memory. |
174 heap_.ReleasePurgedMemory(); | 198 heap_->ReleasePurgedMemory(); |
175 | 199 |
176 // Make sure crash keys are up to date in case allocation fails. | 200 // Make sure crash keys are up to date in case allocation fails. |
177 if (heap_.GetSize() != heap_size_prior_to_releasing_purged_memory) | 201 if (heap_->GetSize() != heap_size_prior_to_releasing_purged_memory) |
178 MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists()); | 202 MemoryUsageChanged(heap_->GetSize(), heap_->GetSizeOfFreeLists()); |
179 | 203 |
180 size_t pages_to_allocate = | 204 size_t pages_to_allocate = |
181 std::max(kAllocationSize / base::GetPageSize(), pages); | 205 std::max(kAllocationSize / base::GetPageSize(), pages); |
182 size_t allocation_size_in_bytes = pages_to_allocate * base::GetPageSize(); | 206 size_t allocation_size_in_bytes = pages_to_allocate * base::GetPageSize(); |
183 | 207 |
184 DiscardableSharedMemoryId new_id = | 208 int32_t new_id = g_next_discardable_shared_memory_id.GetNext(); |
185 g_next_discardable_shared_memory_id.GetNext(); | |
186 | 209 |
187 // Ask parent process to allocate a new discardable shared memory segment. | 210 // Ask parent process to allocate a new discardable shared memory segment. |
188 std::unique_ptr<base::DiscardableSharedMemory> shared_memory( | 211 std::unique_ptr<base::DiscardableSharedMemory> shared_memory = |
189 AllocateLockedDiscardableSharedMemory(allocation_size_in_bytes, new_id)); | 212 AllocateLockedDiscardableSharedMemory(allocation_size_in_bytes, new_id); |
190 | 213 |
191 // Create span for allocated memory. | 214 // Create span for allocated memory. |
192 std::unique_ptr<DiscardableSharedMemoryHeap::Span> new_span( | 215 // Spans are managed by |heap_| (the member of |
193 heap_.Grow(std::move(shared_memory), allocation_size_in_bytes, new_id, | 216 // the ClientDiscardableSharedMemoryManager), so it is safe to use |
194 base::Bind(&SendDeletedDiscardableSharedMemoryMessage, | 217 // base::Unretained(this) here. |
195 delegate_, new_id))); | 218 std::unique_ptr<DiscardableSharedMemoryHeap::Span> new_span(heap_->Grow( |
| 219 std::move(shared_memory), allocation_size_in_bytes, new_id, |
| 220 base::Bind( |
| 221 &ClientDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory, |
| 222 base::Unretained(this), new_id))); |
196 new_span->set_is_locked(true); | 223 new_span->set_is_locked(true); |
197 | 224 |
198 // Unlock and insert any left over memory into free lists. | 225 // Unlock and insert any left over memory into free lists. |
199 if (pages < pages_to_allocate) { | 226 if (pages < pages_to_allocate) { |
200 std::unique_ptr<DiscardableSharedMemoryHeap::Span> leftover = | 227 std::unique_ptr<DiscardableSharedMemoryHeap::Span> leftover = |
201 heap_.Split(new_span.get(), pages); | 228 heap_->Split(new_span.get(), pages); |
202 leftover->shared_memory()->Unlock( | 229 leftover->shared_memory()->Unlock( |
203 leftover->start() * base::GetPageSize() - | 230 leftover->start() * base::GetPageSize() - |
204 reinterpret_cast<size_t>(leftover->shared_memory()->memory()), | 231 reinterpret_cast<size_t>(leftover->shared_memory()->memory()), |
205 leftover->length() * base::GetPageSize()); | 232 leftover->length() * base::GetPageSize()); |
206 leftover->set_is_locked(false); | 233 leftover->set_is_locked(false); |
207 heap_.MergeIntoFreeLists(std::move(leftover)); | 234 heap_->MergeIntoFreeLists(std::move(leftover)); |
208 } | 235 } |
209 | 236 |
210 MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists()); | 237 MemoryUsageChanged(heap_->GetSize(), heap_->GetSizeOfFreeLists()); |
211 | 238 |
212 return base::MakeUnique<DiscardableMemoryImpl>(this, std::move(new_span)); | 239 return base::MakeUnique<DiscardableMemoryImpl>(this, std::move(new_span)); |
213 } | 240 } |
214 | 241 |
215 bool ClientDiscardableSharedMemoryManager::OnMemoryDump( | 242 bool ClientDiscardableSharedMemoryManager::OnMemoryDump( |
216 const base::trace_event::MemoryDumpArgs& args, | 243 const base::trace_event::MemoryDumpArgs& args, |
217 base::trace_event::ProcessMemoryDump* pmd) { | 244 base::trace_event::ProcessMemoryDump* pmd) { |
218 base::AutoLock lock(lock_); | 245 base::AutoLock lock(lock_); |
219 if (args.level_of_detail == | 246 if (args.level_of_detail == |
220 base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) { | 247 base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) { |
221 base::trace_event::MemoryAllocatorDump* total_dump = | 248 base::trace_event::MemoryAllocatorDump* total_dump = |
222 pmd->CreateAllocatorDump( | 249 pmd->CreateAllocatorDump( |
223 base::StringPrintf("discardable/child_0x%" PRIXPTR, | 250 base::StringPrintf("discardable/child_0x%" PRIXPTR, |
224 reinterpret_cast<uintptr_t>(this))); | 251 reinterpret_cast<uintptr_t>(this))); |
225 const size_t total_size = heap_.GetSize(); | 252 const size_t total_size = heap_->GetSize(); |
226 const size_t freelist_size = heap_.GetSizeOfFreeLists(); | 253 const size_t freelist_size = heap_->GetSizeOfFreeLists(); |
227 total_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize, | 254 total_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize, |
228 base::trace_event::MemoryAllocatorDump::kUnitsBytes, | 255 base::trace_event::MemoryAllocatorDump::kUnitsBytes, |
229 total_size - freelist_size); | 256 total_size - freelist_size); |
230 total_dump->AddScalar("freelist_size", | 257 total_dump->AddScalar("freelist_size", |
231 base::trace_event::MemoryAllocatorDump::kUnitsBytes, | 258 base::trace_event::MemoryAllocatorDump::kUnitsBytes, |
232 freelist_size); | 259 freelist_size); |
233 return true; | 260 return true; |
234 } | 261 } |
235 | 262 |
236 return heap_.OnMemoryDump(pmd); | 263 return heap_->OnMemoryDump(pmd); |
237 } | 264 } |
238 | 265 |
239 ClientDiscardableSharedMemoryManager::Statistics | 266 ClientDiscardableSharedMemoryManager::Statistics |
240 ClientDiscardableSharedMemoryManager::GetStatistics() const { | 267 ClientDiscardableSharedMemoryManager::GetStatistics() const { |
241 base::AutoLock lock(lock_); | 268 base::AutoLock lock(lock_); |
242 Statistics stats; | 269 Statistics stats; |
243 stats.total_size = heap_.GetSize(); | 270 stats.total_size = heap_->GetSize(); |
244 stats.freelist_size = heap_.GetSizeOfFreeLists(); | 271 stats.freelist_size = heap_->GetSizeOfFreeLists(); |
245 return stats; | 272 return stats; |
246 } | 273 } |
247 | 274 |
248 void ClientDiscardableSharedMemoryManager::ReleaseFreeMemory() { | 275 void ClientDiscardableSharedMemoryManager::ReleaseFreeMemory() { |
249 base::AutoLock lock(lock_); | 276 base::AutoLock lock(lock_); |
250 | 277 |
251 size_t heap_size_prior_to_releasing_memory = heap_.GetSize(); | 278 size_t heap_size_prior_to_releasing_memory = heap_->GetSize(); |
252 | 279 |
253 // Release both purged and free memory. | 280 // Release both purged and free memory. |
254 heap_.ReleasePurgedMemory(); | 281 heap_->ReleasePurgedMemory(); |
255 heap_.ReleaseFreeMemory(); | 282 heap_->ReleaseFreeMemory(); |
256 | 283 |
257 if (heap_.GetSize() != heap_size_prior_to_releasing_memory) | 284 if (heap_->GetSize() != heap_size_prior_to_releasing_memory) |
258 MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists()); | 285 MemoryUsageChanged(heap_->GetSize(), heap_->GetSizeOfFreeLists()); |
259 } | 286 } |
260 | 287 |
261 bool ClientDiscardableSharedMemoryManager::LockSpan( | 288 bool ClientDiscardableSharedMemoryManager::LockSpan( |
262 DiscardableSharedMemoryHeap::Span* span) { | 289 DiscardableSharedMemoryHeap::Span* span) { |
263 base::AutoLock lock(lock_); | 290 base::AutoLock lock(lock_); |
264 | 291 |
265 if (!span->shared_memory()) | 292 if (!span->shared_memory()) |
266 return false; | 293 return false; |
267 | 294 |
268 size_t offset = span->start() * base::GetPageSize() - | 295 size_t offset = span->start() * base::GetPageSize() - |
(...skipping 30 matching lines...) Expand all Loading... |
299 } | 326 } |
300 | 327 |
301 void ClientDiscardableSharedMemoryManager::ReleaseSpan( | 328 void ClientDiscardableSharedMemoryManager::ReleaseSpan( |
302 std::unique_ptr<DiscardableSharedMemoryHeap::Span> span) { | 329 std::unique_ptr<DiscardableSharedMemoryHeap::Span> span) { |
303 base::AutoLock lock(lock_); | 330 base::AutoLock lock(lock_); |
304 | 331 |
305 // Delete span instead of merging it into free lists if memory is gone. | 332 // Delete span instead of merging it into free lists if memory is gone. |
306 if (!span->shared_memory()) | 333 if (!span->shared_memory()) |
307 return; | 334 return; |
308 | 335 |
309 heap_.MergeIntoFreeLists(std::move(span)); | 336 heap_->MergeIntoFreeLists(std::move(span)); |
310 | 337 |
311 // Bytes of free memory changed. | 338 // Bytes of free memory changed. |
312 MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists()); | 339 MemoryUsageChanged(heap_->GetSize(), heap_->GetSizeOfFreeLists()); |
313 } | 340 } |
314 | 341 |
315 base::trace_event::MemoryAllocatorDump* | 342 base::trace_event::MemoryAllocatorDump* |
316 ClientDiscardableSharedMemoryManager::CreateMemoryAllocatorDump( | 343 ClientDiscardableSharedMemoryManager::CreateMemoryAllocatorDump( |
317 DiscardableSharedMemoryHeap::Span* span, | 344 DiscardableSharedMemoryHeap::Span* span, |
318 const char* name, | 345 const char* name, |
319 base::trace_event::ProcessMemoryDump* pmd) const { | 346 base::trace_event::ProcessMemoryDump* pmd) const { |
320 base::AutoLock lock(lock_); | 347 base::AutoLock lock(lock_); |
321 return heap_.CreateMemoryAllocatorDump(span, name, pmd); | 348 return heap_->CreateMemoryAllocatorDump(span, name, pmd); |
322 } | 349 } |
323 | 350 |
324 std::unique_ptr<base::DiscardableSharedMemory> | 351 std::unique_ptr<base::DiscardableSharedMemory> |
325 ClientDiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory( | 352 ClientDiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory( |
326 size_t size, | 353 size_t size, |
327 DiscardableSharedMemoryId id) { | 354 int32_t id) { |
328 TRACE_EVENT2("renderer", | 355 TRACE_EVENT2("renderer", |
329 "ClientDiscardableSharedMemoryManager::" | 356 "ClientDiscardableSharedMemoryManager::" |
330 "AllocateLockedDiscardableSharedMemory", | 357 "AllocateLockedDiscardableSharedMemory", |
331 "size", size, "id", id); | 358 "size", size, "id", id); |
332 | 359 std::unique_ptr<base::DiscardableSharedMemory> memory; |
333 base::SharedMemoryHandle handle = base::SharedMemory::NULLHandle(); | 360 base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL, |
334 delegate_->AllocateLockedDiscardableSharedMemory(size, id, &handle); | 361 base::WaitableEvent::InitialState::NOT_SIGNALED); |
335 std::unique_ptr<base::DiscardableSharedMemory> memory( | 362 base::ScopedClosureRunner event_signal_runner( |
336 new base::DiscardableSharedMemory(handle)); | 363 base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event))); |
337 if (!memory->Map(size)) | 364 io_task_runner_->PostTask( |
338 base::TerminateBecauseOutOfMemory(size); | 365 FROM_HERE, base::Bind(&ClientDiscardableSharedMemoryManager::AllocateOnIO, |
| 366 base::Unretained(this), size, id, &memory, |
| 367 base::Passed(&event_signal_runner))); |
| 368 // Waiting until IPC has finished on the IO thread. |
| 369 event.Wait(); |
339 return memory; | 370 return memory; |
340 } | 371 } |
341 | 372 |
| 373 void ClientDiscardableSharedMemoryManager::AllocateOnIO( |
| 374 size_t size, |
| 375 int32_t id, |
| 376 std::unique_ptr<base::DiscardableSharedMemory>* memory, |
| 377 base::ScopedClosureRunner closure_runner) { |
| 378 (*manager_mojo_) |
| 379 ->AllocateLockedDiscardableSharedMemory( |
| 380 static_cast<uint32_t>(size), id, |
| 381 base::Bind( |
| 382 &ClientDiscardableSharedMemoryManager::AllocateCompletedOnIO, |
| 383 base::Unretained(this), memory, base::Passed(&closure_runner))); |
| 384 } |
| 385 |
| 386 void ClientDiscardableSharedMemoryManager::AllocateCompletedOnIO( |
| 387 std::unique_ptr<base::DiscardableSharedMemory>* memory, |
| 388 base::ScopedClosureRunner closure_runner, |
| 389 mojo::ScopedSharedBufferHandle mojo_handle) { |
| 390 if (!mojo_handle.is_valid()) |
| 391 return; |
| 392 base::SharedMemoryHandle handle = base::SharedMemory::NULLHandle(); |
| 393 size_t memory_size = 0; |
| 394 bool read_only = false; |
| 395 auto result = mojo::UnwrapSharedMemoryHandle(std::move(mojo_handle), &handle, |
| 396 &memory_size, &read_only); |
| 397 if (result != MOJO_RESULT_OK) |
| 398 return; |
| 399 auto discardable_shared_memory = |
| 400 base::MakeUnique<base::DiscardableSharedMemory>(handle); |
| 401 if (!discardable_shared_memory->Map(memory_size)) |
| 402 base::TerminateBecauseOutOfMemory(memory_size); |
| 403 *memory = std::move(discardable_shared_memory); |
| 404 } |
| 405 |
| 406 void ClientDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory( |
| 407 int32_t id) { |
| 408 io_task_runner_->PostTask( |
| 409 FROM_HERE, |
| 410 base::Bind(&DeletedDiscardableSharedMemoryOnIO, manager_mojo_.get(), id)); |
| 411 } |
| 412 |
342 void ClientDiscardableSharedMemoryManager::MemoryUsageChanged( | 413 void ClientDiscardableSharedMemoryManager::MemoryUsageChanged( |
343 size_t new_bytes_total, | 414 size_t new_bytes_total, |
344 size_t new_bytes_free) const { | 415 size_t new_bytes_free) const { |
345 static const char kDiscardableMemoryAllocatedKey[] = | 416 static const char kDiscardableMemoryAllocatedKey[] = |
346 "discardable-memory-allocated"; | 417 "discardable-memory-allocated"; |
347 base::debug::SetCrashKeyValue(kDiscardableMemoryAllocatedKey, | 418 base::debug::SetCrashKeyValue(kDiscardableMemoryAllocatedKey, |
348 base::Uint64ToString(new_bytes_total)); | 419 base::Uint64ToString(new_bytes_total)); |
349 | 420 |
350 static const char kDiscardableMemoryFreeKey[] = "discardable-memory-free"; | 421 static const char kDiscardableMemoryFreeKey[] = "discardable-memory-free"; |
351 base::debug::SetCrashKeyValue(kDiscardableMemoryFreeKey, | 422 base::debug::SetCrashKeyValue(kDiscardableMemoryFreeKey, |
352 base::Uint64ToString(new_bytes_free)); | 423 base::Uint64ToString(new_bytes_free)); |
353 } | 424 } |
354 | 425 |
355 } // namespace discardable_memory | 426 } // namespace discardable_memory |
OLD | NEW |