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 // mojom::DiscardableSharedMemoryManager implementation. It contains the |
| 63 // |client_id_| which is not visible to client. We associate allocations with a |
| 64 // given mojo instance, so if the instance is closed, we can release the |
| 65 // allocations associated with that instance. |
| 66 class MojoDiscardableSharedMemoryManagerImpl |
| 67 : public mojom::DiscardableSharedMemoryManager { |
| 68 public: |
| 69 MojoDiscardableSharedMemoryManagerImpl( |
| 70 int32_t client_id, |
| 71 ::discardable_memory::DiscardableSharedMemoryManager* manager) |
| 72 : client_id_(client_id), manager_(manager) {} |
| 73 |
| 74 ~MojoDiscardableSharedMemoryManagerImpl() override { |
| 75 // Remove this client from the |manager_|, so all allocated discardable |
| 76 // memory belong to this client will be released. |
| 77 manager_->ClientRemoved(client_id_); |
| 78 } |
| 79 |
| 80 // mojom::DiscardableSharedMemoryManager overrides: |
| 81 void AllocateLockedDiscardableSharedMemory( |
| 82 uint32_t size, |
| 83 int32_t id, |
| 84 const AllocateLockedDiscardableSharedMemoryCallback& callback) override { |
| 85 base::SharedMemoryHandle handle; |
| 86 manager_->AllocateLockedDiscardableSharedMemoryForClient(client_id_, size, |
| 87 id, &handle); |
| 88 mojo::ScopedSharedBufferHandle memory = |
| 89 mojo::WrapSharedMemoryHandle(handle, size, false /* read_only */); |
| 90 return callback.Run(std::move(memory)); |
| 91 } |
| 92 |
| 93 void DeletedDiscardableSharedMemory(int32_t id) override { |
| 94 manager_->ClientDeletedDiscardableSharedMemory(id, client_id_); |
| 95 } |
| 96 |
| 97 private: |
| 98 const int32_t client_id_; |
| 99 ::discardable_memory::DiscardableSharedMemoryManager* const manager_; |
| 100 |
| 101 DISALLOW_COPY_AND_ASSIGN(MojoDiscardableSharedMemoryManagerImpl); |
| 102 }; |
| 103 |
60 class DiscardableMemoryImpl : public base::DiscardableMemory { | 104 class DiscardableMemoryImpl : public base::DiscardableMemory { |
61 public: | 105 public: |
62 DiscardableMemoryImpl( | 106 DiscardableMemoryImpl( |
63 std::unique_ptr<base::DiscardableSharedMemory> shared_memory, | 107 std::unique_ptr<base::DiscardableSharedMemory> shared_memory, |
64 const base::Closure& deleted_callback) | 108 const base::Closure& deleted_callback) |
65 : shared_memory_(std::move(shared_memory)), | 109 : shared_memory_(std::move(shared_memory)), |
66 deleted_callback_(deleted_callback), | 110 deleted_callback_(deleted_callback), |
67 is_locked_(true) {} | 111 is_locked_(true) {} |
68 | 112 |
69 ~DiscardableMemoryImpl() override { | 113 ~DiscardableMemoryImpl() override { |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
173 | 217 |
174 } // namespace | 218 } // namespace |
175 | 219 |
176 DiscardableSharedMemoryManager::MemorySegment::MemorySegment( | 220 DiscardableSharedMemoryManager::MemorySegment::MemorySegment( |
177 std::unique_ptr<base::DiscardableSharedMemory> memory) | 221 std::unique_ptr<base::DiscardableSharedMemory> memory) |
178 : memory_(std::move(memory)) {} | 222 : memory_(std::move(memory)) {} |
179 | 223 |
180 DiscardableSharedMemoryManager::MemorySegment::~MemorySegment() {} | 224 DiscardableSharedMemoryManager::MemorySegment::~MemorySegment() {} |
181 | 225 |
182 DiscardableSharedMemoryManager::DiscardableSharedMemoryManager() | 226 DiscardableSharedMemoryManager::DiscardableSharedMemoryManager() |
183 : default_memory_limit_(GetDefaultMemoryLimit()), | 227 : next_client_id_(1), |
| 228 default_memory_limit_(GetDefaultMemoryLimit()), |
184 memory_limit_(default_memory_limit_), | 229 memory_limit_(default_memory_limit_), |
185 bytes_allocated_(0), | 230 bytes_allocated_(0), |
186 memory_pressure_listener_(new base::MemoryPressureListener( | 231 memory_pressure_listener_(new base::MemoryPressureListener( |
187 base::Bind(&DiscardableSharedMemoryManager::OnMemoryPressure, | 232 base::Bind(&DiscardableSharedMemoryManager::OnMemoryPressure, |
188 base::Unretained(this)))), | 233 base::Unretained(this)))), |
189 // Current thread might not have a task runner in tests. | 234 // Current thread might not have a task runner in tests. |
190 enforce_memory_policy_task_runner_(base::ThreadTaskRunnerHandle::Get()), | 235 enforce_memory_policy_task_runner_(base::ThreadTaskRunnerHandle::Get()), |
191 enforce_memory_policy_pending_(false), | 236 enforce_memory_policy_pending_(false), |
192 weak_ptr_factory_(this) { | 237 weak_ptr_factory_(this) { |
193 DCHECK_NE(memory_limit_, 0u); | 238 DCHECK_NE(memory_limit_, 0u); |
194 enforce_memory_policy_callback_ = | 239 enforce_memory_policy_callback_ = |
195 base::Bind(&DiscardableSharedMemoryManager::EnforceMemoryPolicy, | 240 base::Bind(&DiscardableSharedMemoryManager::EnforceMemoryPolicy, |
196 weak_ptr_factory_.GetWeakPtr()); | 241 weak_ptr_factory_.GetWeakPtr()); |
197 base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( | 242 base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( |
198 this, "DiscardableSharedMemoryManager", | 243 this, "DiscardableSharedMemoryManager", |
199 base::ThreadTaskRunnerHandle::Get()); | 244 base::ThreadTaskRunnerHandle::Get()); |
200 base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this); | 245 base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this); |
201 } | 246 } |
202 | 247 |
203 DiscardableSharedMemoryManager::~DiscardableSharedMemoryManager() { | 248 DiscardableSharedMemoryManager::~DiscardableSharedMemoryManager() { |
204 base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider( | 249 base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider( |
205 this); | 250 this); |
206 } | 251 } |
207 | 252 |
208 DiscardableSharedMemoryManager* DiscardableSharedMemoryManager::current() { | 253 // static |
| 254 DiscardableSharedMemoryManager* |
| 255 DiscardableSharedMemoryManager::CreateInstance() { |
| 256 DCHECK(g_discardable_shared_memory_manager == nullptr); |
209 return g_discardable_shared_memory_manager.Pointer(); | 257 return g_discardable_shared_memory_manager.Pointer(); |
210 } | 258 } |
211 | 259 |
| 260 // static |
| 261 DiscardableSharedMemoryManager* DiscardableSharedMemoryManager::GetInstance() { |
| 262 DCHECK(!(g_discardable_shared_memory_manager == nullptr)); |
| 263 return g_discardable_shared_memory_manager.Pointer(); |
| 264 } |
| 265 |
| 266 void DiscardableSharedMemoryManager::Bind( |
| 267 mojom::DiscardableSharedMemoryManagerRequest request) { |
| 268 mojo::MakeStrongBinding( |
| 269 base::MakeUnique<MojoDiscardableSharedMemoryManagerImpl>( |
| 270 next_client_id_++, this), |
| 271 std::move(request)); |
| 272 } |
| 273 |
212 std::unique_ptr<base::DiscardableMemory> | 274 std::unique_ptr<base::DiscardableMemory> |
213 DiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(size_t size) { | 275 DiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(size_t size) { |
214 DCHECK_NE(size, 0u); | 276 DCHECK_NE(size, 0u); |
215 | 277 |
216 DiscardableSharedMemoryId new_id = | 278 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 | 279 |
220 // Note: Use DiscardableSharedMemoryHeap for in-process allocation | 280 // Note: Use DiscardableSharedMemoryHeap for in-process allocation |
221 // of discardable memory if the cost of each allocation is too high. | 281 // of discardable memory if the cost of each allocation is too high. |
222 base::SharedMemoryHandle handle; | 282 base::SharedMemoryHandle handle; |
223 AllocateLockedDiscardableSharedMemory( | 283 AllocateLockedDiscardableSharedMemory(kInvalidUniqueClientID, size, new_id, |
224 current_process_handle, kInvalidUniqueClientID, size, new_id, &handle); | 284 &handle); |
225 std::unique_ptr<base::DiscardableSharedMemory> memory( | 285 std::unique_ptr<base::DiscardableSharedMemory> memory( |
226 new base::DiscardableSharedMemory(handle)); | 286 new base::DiscardableSharedMemory(handle)); |
227 if (!memory->Map(size)) | 287 if (!memory->Map(size)) |
228 base::TerminateBecauseOutOfMemory(size); | 288 base::TerminateBecauseOutOfMemory(size); |
229 // Close file descriptor to avoid running out. | 289 // Close file descriptor to avoid running out. |
230 memory->Close(); | 290 memory->Close(); |
231 return base::MakeUnique<DiscardableMemoryImpl>( | 291 return base::MakeUnique<DiscardableMemoryImpl>( |
232 std::move(memory), | 292 std::move(memory), |
233 base::Bind( | 293 base::Bind( |
234 &DiscardableSharedMemoryManager::DeletedDiscardableSharedMemory, | 294 &DiscardableSharedMemoryManager::DeletedDiscardableSharedMemory, |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
301 static_cast<uint64_t>(resident_size)); | 361 static_cast<uint64_t>(resident_size)); |
302 } | 362 } |
303 #endif // defined(COUNT_RESIDENT_BYTES_SUPPORTED) | 363 #endif // defined(COUNT_RESIDENT_BYTES_SUPPORTED) |
304 } | 364 } |
305 } | 365 } |
306 return true; | 366 return true; |
307 } | 367 } |
308 | 368 |
309 void DiscardableSharedMemoryManager:: | 369 void DiscardableSharedMemoryManager:: |
310 AllocateLockedDiscardableSharedMemoryForClient( | 370 AllocateLockedDiscardableSharedMemoryForClient( |
311 base::ProcessHandle process_handle, | |
312 int client_id, | 371 int client_id, |
313 size_t size, | 372 size_t size, |
314 DiscardableSharedMemoryId id, | 373 int32_t id, |
315 base::SharedMemoryHandle* shared_memory_handle) { | 374 base::SharedMemoryHandle* shared_memory_handle) { |
316 AllocateLockedDiscardableSharedMemory(process_handle, client_id, size, id, | 375 AllocateLockedDiscardableSharedMemory(client_id, size, id, |
317 shared_memory_handle); | 376 shared_memory_handle); |
318 } | 377 } |
319 | 378 |
320 void DiscardableSharedMemoryManager::ClientDeletedDiscardableSharedMemory( | 379 void DiscardableSharedMemoryManager::ClientDeletedDiscardableSharedMemory( |
321 DiscardableSharedMemoryId id, | 380 int32_t id, |
322 int client_id) { | 381 int client_id) { |
323 DeletedDiscardableSharedMemory(id, client_id); | 382 DeletedDiscardableSharedMemory(id, client_id); |
324 } | 383 } |
325 | 384 |
326 void DiscardableSharedMemoryManager::ClientRemoved(int client_id) { | 385 void DiscardableSharedMemoryManager::ClientRemoved(int client_id) { |
327 base::AutoLock lock(lock_); | 386 base::AutoLock lock(lock_); |
328 | 387 |
329 auto it = clients_.find(client_id); | 388 auto it = clients_.find(client_id); |
330 if (it == clients_.end()) | 389 if (it == clients_.end()) |
331 return; | 390 return; |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
373 case base::MemoryState::SUSPENDED: | 432 case base::MemoryState::SUSPENDED: |
374 // Note that SUSPENDED never occurs in the main browser process so far. | 433 // Note that SUSPENDED never occurs in the main browser process so far. |
375 // Fall through. | 434 // Fall through. |
376 case base::MemoryState::UNKNOWN: | 435 case base::MemoryState::UNKNOWN: |
377 NOTREACHED(); | 436 NOTREACHED(); |
378 break; | 437 break; |
379 } | 438 } |
380 } | 439 } |
381 | 440 |
382 void DiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory( | 441 void DiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory( |
383 base::ProcessHandle process_handle, | |
384 int client_id, | 442 int client_id, |
385 size_t size, | 443 size_t size, |
386 DiscardableSharedMemoryId id, | 444 int32_t id, |
387 base::SharedMemoryHandle* shared_memory_handle) { | 445 base::SharedMemoryHandle* shared_memory_handle) { |
388 base::AutoLock lock(lock_); | 446 base::AutoLock lock(lock_); |
389 | 447 |
390 // Make sure |id| is not already in use. | 448 // Make sure |id| is not already in use. |
391 MemorySegmentMap& client_segments = clients_[client_id]; | 449 MemorySegmentMap& client_segments = clients_[client_id]; |
392 if (client_segments.find(id) != client_segments.end()) { | 450 if (client_segments.find(id) != client_segments.end()) { |
393 LOG(ERROR) << "Invalid discardable shared memory ID"; | 451 LOG(ERROR) << "Invalid discardable shared memory ID"; |
394 *shared_memory_handle = base::SharedMemory::NULLHandle(); | 452 *shared_memory_handle = base::SharedMemory::NULLHandle(); |
395 return; | 453 return; |
396 } | 454 } |
(...skipping 12 matching lines...) Expand all Loading... |
409 if (bytes_allocated_ > limit) | 467 if (bytes_allocated_ > limit) |
410 ReduceMemoryUsageUntilWithinLimit(limit); | 468 ReduceMemoryUsageUntilWithinLimit(limit); |
411 | 469 |
412 std::unique_ptr<base::DiscardableSharedMemory> memory( | 470 std::unique_ptr<base::DiscardableSharedMemory> memory( |
413 new base::DiscardableSharedMemory); | 471 new base::DiscardableSharedMemory); |
414 if (!memory->CreateAndMap(size)) { | 472 if (!memory->CreateAndMap(size)) { |
415 *shared_memory_handle = base::SharedMemory::NULLHandle(); | 473 *shared_memory_handle = base::SharedMemory::NULLHandle(); |
416 return; | 474 return; |
417 } | 475 } |
418 | 476 |
419 if (!memory->ShareToProcess(process_handle, shared_memory_handle)) { | |
420 LOG(ERROR) << "Cannot share discardable memory segment"; | |
421 *shared_memory_handle = base::SharedMemory::NULLHandle(); | |
422 return; | |
423 } | |
424 | |
425 // Close file descriptor to avoid running out. | |
426 memory->Close(); | |
427 | |
428 base::CheckedNumeric<size_t> checked_bytes_allocated = bytes_allocated_; | 477 base::CheckedNumeric<size_t> checked_bytes_allocated = bytes_allocated_; |
429 checked_bytes_allocated += memory->mapped_size(); | 478 checked_bytes_allocated += memory->mapped_size(); |
430 if (!checked_bytes_allocated.IsValid()) { | 479 if (!checked_bytes_allocated.IsValid()) { |
431 *shared_memory_handle = base::SharedMemory::NULLHandle(); | 480 *shared_memory_handle = base::SharedMemory::NULLHandle(); |
432 return; | 481 return; |
433 } | 482 } |
434 | 483 |
435 bytes_allocated_ = checked_bytes_allocated.ValueOrDie(); | 484 bytes_allocated_ = checked_bytes_allocated.ValueOrDie(); |
436 BytesAllocatedChanged(bytes_allocated_); | 485 BytesAllocatedChanged(bytes_allocated_); |
437 | 486 |
| 487 *shared_memory_handle = base::SharedMemory::DuplicateHandle(memory->handle()); |
| 488 // Close file descriptor to avoid running out. |
| 489 memory->Close(); |
| 490 |
438 scoped_refptr<MemorySegment> segment(new MemorySegment(std::move(memory))); | 491 scoped_refptr<MemorySegment> segment(new MemorySegment(std::move(memory))); |
439 client_segments[id] = segment.get(); | 492 client_segments[id] = segment.get(); |
440 segments_.push_back(segment.get()); | 493 segments_.push_back(segment.get()); |
441 std::push_heap(segments_.begin(), segments_.end(), CompareMemoryUsageTime); | 494 std::push_heap(segments_.begin(), segments_.end(), CompareMemoryUsageTime); |
442 | 495 |
443 if (bytes_allocated_ > memory_limit_) | 496 if (bytes_allocated_ > memory_limit_) |
444 ScheduleEnforceMemoryPolicy(); | 497 ScheduleEnforceMemoryPolicy(); |
445 } | 498 } |
446 | 499 |
447 void DiscardableSharedMemoryManager::DeletedDiscardableSharedMemory( | 500 void DiscardableSharedMemoryManager::DeletedDiscardableSharedMemory( |
448 DiscardableSharedMemoryId id, | 501 int32_t id, |
449 int client_id) { | 502 int client_id) { |
450 base::AutoLock lock(lock_); | 503 base::AutoLock lock(lock_); |
451 | 504 |
452 MemorySegmentMap& client_segments = clients_[client_id]; | 505 MemorySegmentMap& client_segments = clients_[client_id]; |
453 | 506 |
454 MemorySegmentMap::iterator segment_it = client_segments.find(id); | 507 MemorySegmentMap::iterator segment_it = client_segments.find(id); |
455 if (segment_it == client_segments.end()) { | 508 if (segment_it == client_segments.end()) { |
456 LOG(ERROR) << "Invalid discardable shared memory ID"; | 509 LOG(ERROR) << "Invalid discardable shared memory ID"; |
457 return; | 510 return; |
458 } | 511 } |
(...skipping 122 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
581 return; | 634 return; |
582 | 635 |
583 enforce_memory_policy_pending_ = true; | 636 enforce_memory_policy_pending_ = true; |
584 DCHECK(enforce_memory_policy_task_runner_); | 637 DCHECK(enforce_memory_policy_task_runner_); |
585 enforce_memory_policy_task_runner_->PostDelayedTask( | 638 enforce_memory_policy_task_runner_->PostDelayedTask( |
586 FROM_HERE, enforce_memory_policy_callback_, | 639 FROM_HERE, enforce_memory_policy_callback_, |
587 base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs)); | 640 base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs)); |
588 } | 641 } |
589 | 642 |
590 } // namespace discardable_memory | 643 } // namespace discardable_memory |
OLD | NEW |