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 OnManagerConnectionError( |
86 ClientDiscardableSharedMemoryManager::Delegate* delegate, | 88 mojom::DiscardableSharedMemoryManagerPtr* manager) { |
87 DiscardableSharedMemoryId id) { | 89 manager->reset(); |
88 delegate->DeletedDiscardableSharedMemory(id); | 90 } |
91 | |
92 void InitManagerOnIOThread(mojom::DiscardableSharedMemoryManagerPtr* manager, | |
reveman
2016/11/18 05:26:50
s/IOThread/IO/ and align this function name with t
Peng
2016/11/18 16:28:27
Done.
Peng
2016/11/18 16:28:27
Done.
| |
93 mojom::DiscardableSharedMemoryManagerPtrInfo info) { | |
94 manager->Bind(std::move(info)); | |
95 manager->set_connection_error_handler( | |
96 base::Bind(&OnManagerConnectionError, manager)); | |
97 } | |
98 | |
99 void DeletedDiscardableSharedMemoryOnIOThread( | |
reveman
2016/11/18 05:26:50
nit: s/OnIOThread/OnIO/
Peng
2016/11/18 16:28:27
Done.
Peng
2016/11/18 16:28:27
Done.
| |
100 mojom::DiscardableSharedMemoryManagerPtr* manager, | |
101 int32_t id) { | |
102 if (!manager->is_bound()) | |
reveman
2016/11/18 05:26:50
when will this happen? can we DCHECK instead?
Peng
2016/11/18 16:28:27
Done.
Peng
2016/11/18 16:28:27
Probably when the browser is being terminated. The
reveman
2016/11/18 21:55:25
Makes sense. Thanks for explaining.
| |
103 return; | |
104 (*manager)->DeletedDiscardableSharedMemory(id); | |
89 } | 105 } |
90 | 106 |
91 } // namespace | 107 } // namespace |
92 | 108 |
93 ClientDiscardableSharedMemoryManager::ClientDiscardableSharedMemoryManager( | 109 ClientDiscardableSharedMemoryManager::ClientDiscardableSharedMemoryManager( |
94 Delegate* delegate) | 110 mojom::DiscardableSharedMemoryManagerPtrInfo info, |
95 : heap_(base::GetPageSize()), delegate_(delegate) { | 111 base::SingleThreadTaskRunner* io_task_runner) |
112 : io_task_runner_(io_task_runner), | |
113 manager_(new mojom::DiscardableSharedMemoryManagerPtr), | |
114 heap_(new DiscardableSharedMemoryHeap(base::GetPageSize())) { | |
96 base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( | 115 base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( |
97 this, "ClientDiscardableSharedMemoryManager", | 116 this, "ClientDiscardableSharedMemoryManager", |
98 base::ThreadTaskRunnerHandle::Get()); | 117 base::ThreadTaskRunnerHandle::Get()); |
118 io_task_runner_->PostTask( | |
119 FROM_HERE, | |
120 base::Bind(&InitManagerOnIOThread, manager_.get(), base::Passed(&info))); | |
99 } | 121 } |
100 | 122 |
101 ClientDiscardableSharedMemoryManager::~ClientDiscardableSharedMemoryManager() { | 123 ClientDiscardableSharedMemoryManager::~ClientDiscardableSharedMemoryManager() { |
102 base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider( | 124 base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider( |
103 this); | 125 this); |
104 // TODO(reveman): Determine if this DCHECK can be enabled. crbug.com/430533 | 126 // TODO(reveman): Determine if this DCHECK can be enabled. crbug.com/430533 |
105 // DCHECK_EQ(heap_.GetSize(), heap_.GetSizeOfFreeLists()); | 127 // DCHECK_EQ(heap_->GetSize(), heap_->GetSizeOfFreeLists()); |
106 if (heap_.GetSize()) | 128 if (heap_->GetSize()) |
107 MemoryUsageChanged(0, 0); | 129 MemoryUsageChanged(0, 0); |
130 heap_.reset(); | |
131 | |
132 // Delete the manager on IO thread, so any pinding tasks on IO thread will be | |
133 // executed before the manager is deleted. | |
134 auto* manager = manager_.release(); | |
135 if (!io_task_runner_->DeleteSoon(FROM_HERE, manager)) | |
reveman
2016/11/18 05:26:50
Can this fail in practice? In that case a wrapper
Peng
2016/11/18 16:28:27
Done.
| |
136 delete manager; | |
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 auto shared_memory = |
reveman
2016/11/18 05:26:50
nit: please keep the explicit type instead of usin
Peng
2016/11/18 16:28:27
Done.
| |
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); |
361 std::unique_ptr<base::DiscardableSharedMemory> memory; | |
362 base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL, | |
363 base::WaitableEvent::InitialState::NOT_SIGNALED); | |
364 io_task_runner_->PostTask( | |
365 FROM_HERE, | |
366 base::Bind(&ClientDiscardableSharedMemoryManager::AllocateOnIOThread, | |
367 base::Unretained(this), size, id, &memory, &event)); | |
368 // Waiting until IPC is finished in the IO thread. | |
reveman
2016/11/18 05:26:50
nit: "...IPC has finished on the IO thread."
Peng
2016/11/18 16:28:27
Done.
| |
369 event.Wait(); | |
370 return memory; | |
371 } | |
332 | 372 |
333 base::SharedMemoryHandle handle = base::SharedMemory::NULLHandle(); | 373 void ClientDiscardableSharedMemoryManager::AllocateOnIOThread( |
334 delegate_->AllocateLockedDiscardableSharedMemory(size, id, &handle); | 374 size_t size, |
335 std::unique_ptr<base::DiscardableSharedMemory> memory( | 375 int32_t id, |
336 new base::DiscardableSharedMemory(handle)); | 376 std::unique_ptr<base::DiscardableSharedMemory>* memory, |
337 if (!memory->Map(size)) | 377 base::WaitableEvent* event) { |
338 base::TerminateBecauseOutOfMemory(size); | 378 if (!manager_->is_bound()) |
reveman
2016/11/18 05:26:50
can this happen? DCHECK instead?
Peng
2016/11/18 16:28:27
When the mojo connection is broken, the |manager_|
| |
339 return memory; | 379 return; |
380 (*manager_)->AllocateLockedDiscardableSharedMemory( | |
381 static_cast<uint32_t>(size), id, | |
382 base::Bind( | |
383 &ClientDiscardableSharedMemoryManager::OnAllocateCompletedOnIOThread, | |
384 base::Unretained(this), memory, event)); | |
385 } | |
386 | |
387 void ClientDiscardableSharedMemoryManager::OnAllocateCompletedOnIOThread( | |
388 std::unique_ptr<base::DiscardableSharedMemory>* memory, | |
389 base::WaitableEvent* event, | |
390 mojo::ScopedSharedBufferHandle mojo_handle) { | |
391 do { | |
reveman
2016/11/18 05:26:50
Why this loop? I think the code would be easier to
Peng
2016/11/18 16:28:27
Done.
| |
392 if (!mojo_handle.is_valid()) | |
393 break; | |
394 auto handle = base::SharedMemory::NULLHandle(); | |
reveman
2016/11/18 05:26:50
Can you avoid using auto here an below so it's mor
Peng
2016/11/18 16:28:27
Done.
| |
395 size_t memory_size = 0; | |
396 bool read_only = false; | |
397 auto result = mojo::UnwrapSharedMemoryHandle( | |
398 std::move(mojo_handle), &handle, &memory_size, &read_only); | |
399 if (result != MOJO_RESULT_OK) | |
400 break; | |
401 auto discardable_shared_memory = | |
402 base::MakeUnique<base::DiscardableSharedMemory>(handle); | |
403 if (!discardable_shared_memory->Map(memory_size)) { | |
404 base::TerminateBecauseOutOfMemory(memory_size); | |
reveman
2016/11/18 05:26:49
nit: base::TerminateBecauseOutOfMemory never retur
Peng
2016/11/18 16:28:27
Done.
| |
405 break; | |
406 } | |
407 *memory = std::move(discardable_shared_memory); | |
408 } while (false); | |
409 event->Signal(); | |
410 } | |
411 | |
412 void ClientDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory( | |
413 int32_t id) { | |
414 io_task_runner_->PostTask( | |
415 FROM_HERE, base::Bind(&DeletedDiscardableSharedMemoryOnIOThread, | |
416 manager_.get(), id)); | |
340 } | 417 } |
341 | 418 |
342 void ClientDiscardableSharedMemoryManager::MemoryUsageChanged( | 419 void ClientDiscardableSharedMemoryManager::MemoryUsageChanged( |
343 size_t new_bytes_total, | 420 size_t new_bytes_total, |
344 size_t new_bytes_free) const { | 421 size_t new_bytes_free) const { |
345 static const char kDiscardableMemoryAllocatedKey[] = | 422 static const char kDiscardableMemoryAllocatedKey[] = |
346 "discardable-memory-allocated"; | 423 "discardable-memory-allocated"; |
347 base::debug::SetCrashKeyValue(kDiscardableMemoryAllocatedKey, | 424 base::debug::SetCrashKeyValue(kDiscardableMemoryAllocatedKey, |
348 base::Uint64ToString(new_bytes_total)); | 425 base::Uint64ToString(new_bytes_total)); |
349 | 426 |
350 static const char kDiscardableMemoryFreeKey[] = "discardable-memory-free"; | 427 static const char kDiscardableMemoryFreeKey[] = "discardable-memory-free"; |
351 base::debug::SetCrashKeyValue(kDiscardableMemoryFreeKey, | 428 base::debug::SetCrashKeyValue(kDiscardableMemoryFreeKey, |
352 base::Uint64ToString(new_bytes_free)); | 429 base::Uint64ToString(new_bytes_free)); |
353 } | 430 } |
354 | 431 |
355 } // namespace discardable_memory | 432 } // namespace discardable_memory |
OLD | NEW |