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