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/service/discardable_shared_memory_manage
r.h" | 5 #include "components/discardable_memory/service/discardable_shared_memory_manage
r.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/atomic_sequence_num.h" | 10 #include "base/atomic_sequence_num.h" |
(...skipping 11 matching lines...) Expand all Loading... |
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/sys_info.h" | 24 #include "base/sys_info.h" |
25 #include "base/threading/thread_task_runner_handle.h" | 25 #include "base/threading/thread_task_runner_handle.h" |
26 #include "base/trace_event/memory_allocator_dump.h" | 26 #include "base/trace_event/memory_allocator_dump.h" |
27 #include "base/trace_event/memory_dump_manager.h" | 27 #include "base/trace_event/memory_dump_manager.h" |
28 #include "base/trace_event/process_memory_dump.h" | 28 #include "base/trace_event/process_memory_dump.h" |
29 #include "base/trace_event/trace_event.h" | 29 #include "base/trace_event/trace_event.h" |
30 #include "build/build_config.h" | 30 #include "build/build_config.h" |
31 #include "components/discardable_memory/common/discardable_shared_memory_heap.h" | 31 #include "components/discardable_memory/common/discardable_shared_memory_heap.h" |
| 32 #include "mojo/public/cpp/bindings/strong_binding.h" |
| 33 #include "mojo/public/cpp/system/platform_handle.h" |
32 | 34 |
33 #if defined(OS_LINUX) | 35 #if defined(OS_LINUX) |
34 #include "base/files/file_path.h" | 36 #include "base/files/file_path.h" |
35 #include "base/files/file_util.h" | 37 #include "base/files/file_util.h" |
36 #include "base/metrics/histogram_macros.h" | 38 #include "base/metrics/histogram_macros.h" |
37 #endif | 39 #endif |
38 | 40 |
39 namespace discardable_memory { | 41 namespace discardable_memory { |
40 namespace { | 42 namespace { |
41 | 43 |
42 const char kSingleProcess[] = "single-process"; | 44 const char kSingleProcess[] = "single-process"; |
43 | 45 |
44 const int kInvalidUniqueClientID = -1; | 46 const int kInvalidUniqueClientID = -1; |
45 | 47 |
46 const uint64_t kBrowserTracingProcessId = std::numeric_limits<uint64_t>::max(); | 48 const uint64_t kBrowserTracingProcessId = std::numeric_limits<uint64_t>::max(); |
47 | 49 |
48 uint64_t ClientProcessUniqueIdToTracingProcessId(int client_id) { | 50 uint64_t ClientProcessUniqueIdToTracingProcessId(int client_id) { |
49 // TODO(penghuang): Move this function to right place. | 51 // TODO(penghuang): Move this function to right place. |
50 // https://crbug.com/661257 | 52 // https://crbug.com/661257 |
51 if (base::CommandLine::ForCurrentProcess()->HasSwitch(kSingleProcess)) | 53 if (base::CommandLine::ForCurrentProcess()->HasSwitch(kSingleProcess)) |
52 return kBrowserTracingProcessId; | 54 return kBrowserTracingProcessId; |
53 // The hash value is incremented so that the tracing id is never equal to | 55 // The hash value is incremented so that the tracing id is never equal to |
54 // MemoryDumpManager::kInvalidTracingProcessId. | 56 // MemoryDumpManager::kInvalidTracingProcessId. |
55 return static_cast<uint64_t>(base::Hash( | 57 return static_cast<uint64_t>(base::Hash( |
56 reinterpret_cast<const char*>(&client_id), sizeof(client_id))) + | 58 reinterpret_cast<const char*>(&client_id), sizeof(client_id))) + |
57 1; | 59 1; |
58 } | 60 } |
59 | 61 |
| 62 class DiscardableSharedMemoryManagerProxy |
| 63 : public mojom::DiscardableSharedMemoryManager { |
| 64 public: |
| 65 DiscardableSharedMemoryManagerProxy( |
| 66 int32_t client_id, |
| 67 ::discardable_memory::DiscardableSharedMemoryManager* manager) |
| 68 : client_id_(client_id), manager_(manager) {} |
| 69 |
| 70 ~DiscardableSharedMemoryManagerProxy() override { |
| 71 manager_->ClientRemoved(client_id_); |
| 72 } |
| 73 |
| 74 // mojom::DiscardableSharedMemoryManager overrides: |
| 75 void AllocateLockedDiscardableSharedMemory( |
| 76 uint32_t size, |
| 77 int32_t id, |
| 78 const AllocateLockedDiscardableSharedMemoryCallback& callback) override { |
| 79 base::SharedMemoryHandle handle; |
| 80 manager_->AllocateLockedDiscardableSharedMemoryForClient(client_id_, size, |
| 81 id, &handle); |
| 82 mojo::ScopedSharedBufferHandle memory; |
| 83 if (handle != base::SharedMemory::NULLHandle()) { |
| 84 memory = |
| 85 mojo::WrapSharedMemoryHandle(handle, size, false /* ready_only */); |
| 86 } |
| 87 return callback.Run(std::move(memory)); |
| 88 } |
| 89 |
| 90 void DeletedDiscardableSharedMemory(int32_t id) override { |
| 91 manager_->ClientRemoved(client_id_); |
| 92 } |
| 93 |
| 94 private: |
| 95 const int32_t client_id_; |
| 96 ::discardable_memory::DiscardableSharedMemoryManager* const manager_; |
| 97 |
| 98 DISALLOW_COPY_AND_ASSIGN(DiscardableSharedMemoryManagerProxy); |
| 99 }; |
| 100 |
60 class DiscardableMemoryImpl : public base::DiscardableMemory { | 101 class DiscardableMemoryImpl : public base::DiscardableMemory { |
61 public: | 102 public: |
62 DiscardableMemoryImpl( | 103 DiscardableMemoryImpl( |
63 std::unique_ptr<base::DiscardableSharedMemory> shared_memory, | 104 std::unique_ptr<base::DiscardableSharedMemory> shared_memory, |
64 const base::Closure& deleted_callback) | 105 const base::Closure& deleted_callback) |
65 : shared_memory_(std::move(shared_memory)), | 106 : shared_memory_(std::move(shared_memory)), |
66 deleted_callback_(deleted_callback), | 107 deleted_callback_(deleted_callback), |
67 is_locked_(true) {} | 108 is_locked_(true) {} |
68 | 109 |
69 ~DiscardableMemoryImpl() override { | 110 ~DiscardableMemoryImpl() override { |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
173 | 214 |
174 } // namespace | 215 } // namespace |
175 | 216 |
176 DiscardableSharedMemoryManager::MemorySegment::MemorySegment( | 217 DiscardableSharedMemoryManager::MemorySegment::MemorySegment( |
177 std::unique_ptr<base::DiscardableSharedMemory> memory) | 218 std::unique_ptr<base::DiscardableSharedMemory> memory) |
178 : memory_(std::move(memory)) {} | 219 : memory_(std::move(memory)) {} |
179 | 220 |
180 DiscardableSharedMemoryManager::MemorySegment::~MemorySegment() {} | 221 DiscardableSharedMemoryManager::MemorySegment::~MemorySegment() {} |
181 | 222 |
182 DiscardableSharedMemoryManager::DiscardableSharedMemoryManager() | 223 DiscardableSharedMemoryManager::DiscardableSharedMemoryManager() |
183 : default_memory_limit_(GetDefaultMemoryLimit()), | 224 : last_client_id_(0), |
| 225 default_memory_limit_(GetDefaultMemoryLimit()), |
184 memory_limit_(default_memory_limit_), | 226 memory_limit_(default_memory_limit_), |
185 bytes_allocated_(0), | 227 bytes_allocated_(0), |
186 memory_pressure_listener_(new base::MemoryPressureListener( | 228 memory_pressure_listener_(new base::MemoryPressureListener( |
187 base::Bind(&DiscardableSharedMemoryManager::OnMemoryPressure, | 229 base::Bind(&DiscardableSharedMemoryManager::OnMemoryPressure, |
188 base::Unretained(this)))), | 230 base::Unretained(this)))), |
189 // Current thread might not have a task runner in tests. | 231 // Current thread might not have a task runner in tests. |
190 enforce_memory_policy_task_runner_(base::ThreadTaskRunnerHandle::Get()), | 232 enforce_memory_policy_task_runner_(base::ThreadTaskRunnerHandle::Get()), |
191 enforce_memory_policy_pending_(false), | 233 enforce_memory_policy_pending_(false), |
192 weak_ptr_factory_(this) { | 234 weak_ptr_factory_(this) { |
193 DCHECK_NE(memory_limit_, 0u); | 235 DCHECK_NE(memory_limit_, 0u); |
194 enforce_memory_policy_callback_ = | 236 enforce_memory_policy_callback_ = |
195 base::Bind(&DiscardableSharedMemoryManager::EnforceMemoryPolicy, | 237 base::Bind(&DiscardableSharedMemoryManager::EnforceMemoryPolicy, |
196 weak_ptr_factory_.GetWeakPtr()); | 238 weak_ptr_factory_.GetWeakPtr()); |
197 base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( | 239 base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( |
198 this, "DiscardableSharedMemoryManager", | 240 this, "DiscardableSharedMemoryManager", |
199 base::ThreadTaskRunnerHandle::Get()); | 241 base::ThreadTaskRunnerHandle::Get()); |
200 base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this); | 242 base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this); |
201 } | 243 } |
202 | 244 |
203 DiscardableSharedMemoryManager::~DiscardableSharedMemoryManager() { | 245 DiscardableSharedMemoryManager::~DiscardableSharedMemoryManager() { |
204 base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider( | 246 base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider( |
205 this); | 247 this); |
206 } | 248 } |
207 | 249 |
| 250 // static |
208 DiscardableSharedMemoryManager* DiscardableSharedMemoryManager::current() { | 251 DiscardableSharedMemoryManager* DiscardableSharedMemoryManager::current() { |
209 return g_discardable_shared_memory_manager.Pointer(); | 252 return g_discardable_shared_memory_manager.Pointer(); |
210 } | 253 } |
211 | 254 |
| 255 // static |
| 256 void DiscardableSharedMemoryManager::Bind( |
| 257 mojom::DiscardableSharedMemoryManagerRequest request) { |
| 258 auto* manager = current(); |
| 259 mojo::MakeStrongBinding(base::MakeUnique<DiscardableSharedMemoryManagerProxy>( |
| 260 ++manager->last_client_id_, manager), |
| 261 std::move(request)); |
| 262 } |
| 263 |
212 std::unique_ptr<base::DiscardableMemory> | 264 std::unique_ptr<base::DiscardableMemory> |
213 DiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(size_t size) { | 265 DiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(size_t size) { |
214 DCHECK_NE(size, 0u); | 266 DCHECK_NE(size, 0u); |
215 | 267 |
216 DiscardableSharedMemoryId new_id = | 268 int32_t new_id = g_next_discardable_shared_memory_id.GetNext(); |
217 g_next_discardable_shared_memory_id.GetNext(); | |
218 base::ProcessHandle current_process_handle = base::GetCurrentProcessHandle(); | |
219 | 269 |
220 // Note: Use DiscardableSharedMemoryHeap for in-process allocation | 270 // Note: Use DiscardableSharedMemoryHeap for in-process allocation |
221 // of discardable memory if the cost of each allocation is too high. | 271 // of discardable memory if the cost of each allocation is too high. |
222 base::SharedMemoryHandle handle; | 272 base::SharedMemoryHandle handle; |
223 AllocateLockedDiscardableSharedMemory( | 273 AllocateLockedDiscardableSharedMemory(kInvalidUniqueClientID, size, new_id, |
224 current_process_handle, kInvalidUniqueClientID, size, new_id, &handle); | 274 &handle); |
225 std::unique_ptr<base::DiscardableSharedMemory> memory( | 275 std::unique_ptr<base::DiscardableSharedMemory> memory( |
226 new base::DiscardableSharedMemory(handle)); | 276 new base::DiscardableSharedMemory(handle)); |
227 if (!memory->Map(size)) | 277 if (!memory->Map(size)) |
228 base::TerminateBecauseOutOfMemory(size); | 278 base::TerminateBecauseOutOfMemory(size); |
229 // Close file descriptor to avoid running out. | 279 // Close file descriptor to avoid running out. |
230 memory->Close(); | 280 memory->Close(); |
231 return base::MakeUnique<DiscardableMemoryImpl>( | 281 return base::MakeUnique<DiscardableMemoryImpl>( |
232 std::move(memory), | 282 std::move(memory), |
233 base::Bind( | 283 base::Bind( |
234 &DiscardableSharedMemoryManager::DeletedDiscardableSharedMemory, | 284 &DiscardableSharedMemoryManager::DeletedDiscardableSharedMemory, |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
301 static_cast<uint64_t>(resident_size)); | 351 static_cast<uint64_t>(resident_size)); |
302 } | 352 } |
303 #endif // defined(COUNT_RESIDENT_BYTES_SUPPORTED) | 353 #endif // defined(COUNT_RESIDENT_BYTES_SUPPORTED) |
304 } | 354 } |
305 } | 355 } |
306 return true; | 356 return true; |
307 } | 357 } |
308 | 358 |
309 void DiscardableSharedMemoryManager:: | 359 void DiscardableSharedMemoryManager:: |
310 AllocateLockedDiscardableSharedMemoryForClient( | 360 AllocateLockedDiscardableSharedMemoryForClient( |
311 base::ProcessHandle process_handle, | |
312 int client_id, | 361 int client_id, |
313 size_t size, | 362 size_t size, |
314 DiscardableSharedMemoryId id, | 363 int32_t id, |
315 base::SharedMemoryHandle* shared_memory_handle) { | 364 base::SharedMemoryHandle* shared_memory_handle) { |
316 AllocateLockedDiscardableSharedMemory(process_handle, client_id, size, id, | 365 AllocateLockedDiscardableSharedMemory(client_id, size, id, |
317 shared_memory_handle); | 366 shared_memory_handle); |
318 } | 367 } |
319 | 368 |
320 void DiscardableSharedMemoryManager::ClientDeletedDiscardableSharedMemory( | 369 void DiscardableSharedMemoryManager::ClientDeletedDiscardableSharedMemory( |
321 DiscardableSharedMemoryId id, | 370 int32_t id, |
322 int client_id) { | 371 int client_id) { |
323 DeletedDiscardableSharedMemory(id, client_id); | 372 DeletedDiscardableSharedMemory(id, client_id); |
324 } | 373 } |
325 | 374 |
326 void DiscardableSharedMemoryManager::ClientRemoved(int client_id) { | 375 void DiscardableSharedMemoryManager::ClientRemoved(int client_id) { |
327 base::AutoLock lock(lock_); | 376 base::AutoLock lock(lock_); |
328 | 377 |
329 auto it = clients_.find(client_id); | 378 auto it = clients_.find(client_id); |
330 if (it == clients_.end()) | 379 if (it == clients_.end()) |
331 return; | 380 return; |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
373 case base::MemoryState::SUSPENDED: | 422 case base::MemoryState::SUSPENDED: |
374 // Note that SUSPENDED never occurs in the main browser process so far. | 423 // Note that SUSPENDED never occurs in the main browser process so far. |
375 // Fall through. | 424 // Fall through. |
376 case base::MemoryState::UNKNOWN: | 425 case base::MemoryState::UNKNOWN: |
377 NOTREACHED(); | 426 NOTREACHED(); |
378 break; | 427 break; |
379 } | 428 } |
380 } | 429 } |
381 | 430 |
382 void DiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory( | 431 void DiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory( |
383 base::ProcessHandle process_handle, | |
384 int client_id, | 432 int client_id, |
385 size_t size, | 433 size_t size, |
386 DiscardableSharedMemoryId id, | 434 int32_t id, |
387 base::SharedMemoryHandle* shared_memory_handle) { | 435 base::SharedMemoryHandle* shared_memory_handle) { |
388 base::AutoLock lock(lock_); | 436 base::AutoLock lock(lock_); |
389 | 437 |
390 // Make sure |id| is not already in use. | 438 // Make sure |id| is not already in use. |
391 MemorySegmentMap& client_segments = clients_[client_id]; | 439 MemorySegmentMap& client_segments = clients_[client_id]; |
392 if (client_segments.find(id) != client_segments.end()) { | 440 if (client_segments.find(id) != client_segments.end()) { |
393 LOG(ERROR) << "Invalid discardable shared memory ID"; | 441 LOG(ERROR) << "Invalid discardable shared memory ID"; |
394 *shared_memory_handle = base::SharedMemory::NULLHandle(); | 442 *shared_memory_handle = base::SharedMemory::NULLHandle(); |
395 return; | 443 return; |
396 } | 444 } |
(...skipping 12 matching lines...) Expand all Loading... |
409 if (bytes_allocated_ > limit) | 457 if (bytes_allocated_ > limit) |
410 ReduceMemoryUsageUntilWithinLimit(limit); | 458 ReduceMemoryUsageUntilWithinLimit(limit); |
411 | 459 |
412 std::unique_ptr<base::DiscardableSharedMemory> memory( | 460 std::unique_ptr<base::DiscardableSharedMemory> memory( |
413 new base::DiscardableSharedMemory); | 461 new base::DiscardableSharedMemory); |
414 if (!memory->CreateAndMap(size)) { | 462 if (!memory->CreateAndMap(size)) { |
415 *shared_memory_handle = base::SharedMemory::NULLHandle(); | 463 *shared_memory_handle = base::SharedMemory::NULLHandle(); |
416 return; | 464 return; |
417 } | 465 } |
418 | 466 |
419 if (!memory->ShareToProcess(process_handle, shared_memory_handle)) { | 467 *shared_memory_handle = base::SharedMemory::DuplicateHandle(memory->handle()); |
420 LOG(ERROR) << "Cannot share discardable memory segment"; | |
421 *shared_memory_handle = base::SharedMemory::NULLHandle(); | |
422 return; | |
423 } | |
424 | 468 |
425 // Close file descriptor to avoid running out. | 469 // Close file descriptor to avoid running out. |
426 memory->Close(); | 470 memory->Close(); |
427 | 471 |
428 base::CheckedNumeric<size_t> checked_bytes_allocated = bytes_allocated_; | 472 base::CheckedNumeric<size_t> checked_bytes_allocated = bytes_allocated_; |
429 checked_bytes_allocated += memory->mapped_size(); | 473 checked_bytes_allocated += memory->mapped_size(); |
430 if (!checked_bytes_allocated.IsValid()) { | 474 if (!checked_bytes_allocated.IsValid()) { |
431 *shared_memory_handle = base::SharedMemory::NULLHandle(); | 475 *shared_memory_handle = base::SharedMemory::NULLHandle(); |
432 return; | 476 return; |
433 } | 477 } |
434 | 478 |
435 bytes_allocated_ = checked_bytes_allocated.ValueOrDie(); | 479 bytes_allocated_ = checked_bytes_allocated.ValueOrDie(); |
436 BytesAllocatedChanged(bytes_allocated_); | 480 BytesAllocatedChanged(bytes_allocated_); |
437 | 481 |
438 scoped_refptr<MemorySegment> segment(new MemorySegment(std::move(memory))); | 482 scoped_refptr<MemorySegment> segment(new MemorySegment(std::move(memory))); |
439 client_segments[id] = segment.get(); | 483 client_segments[id] = segment.get(); |
440 segments_.push_back(segment.get()); | 484 segments_.push_back(segment.get()); |
441 std::push_heap(segments_.begin(), segments_.end(), CompareMemoryUsageTime); | 485 std::push_heap(segments_.begin(), segments_.end(), CompareMemoryUsageTime); |
442 | 486 |
443 if (bytes_allocated_ > memory_limit_) | 487 if (bytes_allocated_ > memory_limit_) |
444 ScheduleEnforceMemoryPolicy(); | 488 ScheduleEnforceMemoryPolicy(); |
445 } | 489 } |
446 | 490 |
447 void DiscardableSharedMemoryManager::DeletedDiscardableSharedMemory( | 491 void DiscardableSharedMemoryManager::DeletedDiscardableSharedMemory( |
448 DiscardableSharedMemoryId id, | 492 int32_t id, |
449 int client_id) { | 493 int client_id) { |
450 base::AutoLock lock(lock_); | 494 base::AutoLock lock(lock_); |
451 | 495 |
452 MemorySegmentMap& client_segments = clients_[client_id]; | 496 MemorySegmentMap& client_segments = clients_[client_id]; |
453 | 497 |
454 MemorySegmentMap::iterator segment_it = client_segments.find(id); | 498 MemorySegmentMap::iterator segment_it = client_segments.find(id); |
455 if (segment_it == client_segments.end()) { | 499 if (segment_it == client_segments.end()) { |
456 LOG(ERROR) << "Invalid discardable shared memory ID"; | 500 LOG(ERROR) << "Invalid discardable shared memory ID"; |
457 return; | 501 return; |
458 } | 502 } |
(...skipping 122 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
581 return; | 625 return; |
582 | 626 |
583 enforce_memory_policy_pending_ = true; | 627 enforce_memory_policy_pending_ = true; |
584 DCHECK(enforce_memory_policy_task_runner_); | 628 DCHECK(enforce_memory_policy_task_runner_); |
585 enforce_memory_policy_task_runner_->PostDelayedTask( | 629 enforce_memory_policy_task_runner_->PostDelayedTask( |
586 FROM_HERE, enforce_memory_policy_callback_, | 630 FROM_HERE, enforce_memory_policy_callback_, |
587 base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs)); | 631 base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs)); |
588 } | 632 } |
589 | 633 |
590 } // namespace discardable_memory | 634 } // namespace discardable_memory |
OLD | NEW |