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 "content/common/host_discardable_shared_memory_manager.h" | 5 #include "components/discardable_memory/common/discardable_shared_memory_manager
.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" |
11 #include "base/bind.h" | 11 #include "base/bind.h" |
12 #include "base/callback.h" | 12 #include "base/callback.h" |
13 #include "base/debug/crash_logging.h" | 13 #include "base/debug/crash_logging.h" |
14 #include "base/lazy_instance.h" | 14 #include "base/lazy_instance.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/memory_coordinator_client_registry.h" | 17 #include "base/memory/memory_coordinator_client_registry.h" |
18 #include "base/memory/ptr_util.h" | 18 #include "base/memory/ptr_util.h" |
19 #include "base/numerics/safe_math.h" | 19 #include "base/numerics/safe_math.h" |
20 #include "base/process/memory.h" | 20 #include "base/process/memory.h" |
21 #include "base/strings/string_number_conversions.h" | 21 #include "base/strings/string_number_conversions.h" |
22 #include "base/strings/stringprintf.h" | 22 #include "base/strings/stringprintf.h" |
23 #include "base/sys_info.h" | 23 #include "base/sys_info.h" |
24 #include "base/threading/thread_task_runner_handle.h" | 24 #include "base/threading/thread_task_runner_handle.h" |
25 #include "base/trace_event/memory_allocator_dump.h" | 25 #include "base/trace_event/memory_allocator_dump.h" |
26 #include "base/trace_event/memory_dump_manager.h" | 26 #include "base/trace_event/memory_dump_manager.h" |
27 #include "base/trace_event/process_memory_dump.h" | 27 #include "base/trace_event/process_memory_dump.h" |
28 #include "base/trace_event/trace_event.h" | 28 #include "base/trace_event/trace_event.h" |
29 #include "build/build_config.h" | 29 #include "build/build_config.h" |
30 #include "content/common/child_process_host_impl.h" | 30 #include "components/discardable_memory/common/discardable_shared_memory_heap.h" |
31 #include "content/common/discardable_shared_memory_heap.h" | |
32 #include "content/public/common/child_process_host.h" | |
33 | 31 |
34 #if defined(OS_LINUX) | 32 #if defined(OS_LINUX) |
35 #include "base/files/file_path.h" | 33 #include "base/files/file_path.h" |
36 #include "base/files/file_util.h" | 34 #include "base/files/file_util.h" |
37 #include "base/metrics/histogram_macros.h" | 35 #include "base/metrics/histogram_macros.h" |
38 #endif | 36 #endif |
39 | 37 |
40 namespace content { | 38 namespace discardable_memory { |
41 namespace { | 39 namespace { |
42 | 40 |
| 41 const int kInvalidUniqueClientID = -1; |
| 42 |
| 43 uint64_t ClientIdToClientTracingId(int client_id) { |
| 44 // TODO(penghuang): Using a meaningful tracing id. |
| 45 return client_id; |
| 46 } |
| 47 |
43 class DiscardableMemoryImpl : public base::DiscardableMemory { | 48 class DiscardableMemoryImpl : public base::DiscardableMemory { |
44 public: | 49 public: |
45 DiscardableMemoryImpl( | 50 DiscardableMemoryImpl( |
46 std::unique_ptr<base::DiscardableSharedMemory> shared_memory, | 51 std::unique_ptr<base::DiscardableSharedMemory> shared_memory, |
47 const base::Closure& deleted_callback) | 52 const base::Closure& deleted_callback) |
48 : shared_memory_(std::move(shared_memory)), | 53 : shared_memory_(std::move(shared_memory)), |
49 deleted_callback_(deleted_callback), | 54 deleted_callback_(deleted_callback), |
50 is_locked_(true) {} | 55 is_locked_(true) {} |
51 | 56 |
52 ~DiscardableMemoryImpl() override { | 57 ~DiscardableMemoryImpl() override { |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
139 max_default_memory_limit = | 144 max_default_memory_limit = |
140 std::min(max_default_memory_limit, shmem_dir_amount_of_free_space / 2); | 145 std::min(max_default_memory_limit, shmem_dir_amount_of_free_space / 2); |
141 } | 146 } |
142 #endif | 147 #endif |
143 | 148 |
144 // Allow 25% of physical memory to be used for discardable memory. | 149 // Allow 25% of physical memory to be used for discardable memory. |
145 return std::min(max_default_memory_limit, | 150 return std::min(max_default_memory_limit, |
146 base::SysInfo::AmountOfPhysicalMemory() / 4); | 151 base::SysInfo::AmountOfPhysicalMemory() / 4); |
147 } | 152 } |
148 | 153 |
149 base::LazyInstance<HostDiscardableSharedMemoryManager> | 154 base::LazyInstance<DiscardableSharedMemoryManager> |
150 g_discardable_shared_memory_manager = LAZY_INSTANCE_INITIALIZER; | 155 g_discardable_shared_memory_manager = LAZY_INSTANCE_INITIALIZER; |
151 | 156 |
152 const int kEnforceMemoryPolicyDelayMs = 1000; | 157 const int kEnforceMemoryPolicyDelayMs = 1000; |
153 | 158 |
154 // Global atomic to generate unique discardable shared memory IDs. | 159 // Global atomic to generate unique discardable shared memory IDs. |
155 base::StaticAtomicSequenceNumber g_next_discardable_shared_memory_id; | 160 base::StaticAtomicSequenceNumber g_next_discardable_shared_memory_id; |
156 | 161 |
157 } // namespace | 162 } // namespace |
158 | 163 |
159 HostDiscardableSharedMemoryManager::MemorySegment::MemorySegment( | 164 DiscardableSharedMemoryManager::MemorySegment::MemorySegment( |
160 std::unique_ptr<base::DiscardableSharedMemory> memory) | 165 std::unique_ptr<base::DiscardableSharedMemory> memory) |
161 : memory_(std::move(memory)) {} | 166 : memory_(std::move(memory)) {} |
162 | 167 |
163 HostDiscardableSharedMemoryManager::MemorySegment::~MemorySegment() { | 168 DiscardableSharedMemoryManager::MemorySegment::~MemorySegment() {} |
164 } | |
165 | 169 |
166 HostDiscardableSharedMemoryManager::HostDiscardableSharedMemoryManager() | 170 DiscardableSharedMemoryManager::DiscardableSharedMemoryManager() |
167 : default_memory_limit_(GetDefaultMemoryLimit()), | 171 : default_memory_limit_(GetDefaultMemoryLimit()), |
168 memory_limit_(default_memory_limit_), | 172 memory_limit_(default_memory_limit_), |
169 bytes_allocated_(0), | 173 bytes_allocated_(0), |
170 memory_pressure_listener_(new base::MemoryPressureListener( | 174 memory_pressure_listener_(new base::MemoryPressureListener( |
171 base::Bind(&HostDiscardableSharedMemoryManager::OnMemoryPressure, | 175 base::Bind(&DiscardableSharedMemoryManager::OnMemoryPressure, |
172 base::Unretained(this)))), | 176 base::Unretained(this)))), |
173 // Current thread might not have a task runner in tests. | 177 // Current thread might not have a task runner in tests. |
174 enforce_memory_policy_task_runner_(base::ThreadTaskRunnerHandle::Get()), | 178 enforce_memory_policy_task_runner_(base::ThreadTaskRunnerHandle::Get()), |
175 enforce_memory_policy_pending_(false), | 179 enforce_memory_policy_pending_(false), |
176 weak_ptr_factory_(this) { | 180 weak_ptr_factory_(this) { |
177 DCHECK_NE(memory_limit_, 0u); | 181 DCHECK_NE(memory_limit_, 0u); |
178 enforce_memory_policy_callback_ = | 182 enforce_memory_policy_callback_ = |
179 base::Bind(&HostDiscardableSharedMemoryManager::EnforceMemoryPolicy, | 183 base::Bind(&DiscardableSharedMemoryManager::EnforceMemoryPolicy, |
180 weak_ptr_factory_.GetWeakPtr()); | 184 weak_ptr_factory_.GetWeakPtr()); |
181 base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( | 185 base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( |
182 this, "HostDiscardableSharedMemoryManager", | 186 this, "DiscardableSharedMemoryManager", |
183 base::ThreadTaskRunnerHandle::Get()); | 187 base::ThreadTaskRunnerHandle::Get()); |
184 base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this); | 188 base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this); |
185 } | 189 } |
186 | 190 |
187 HostDiscardableSharedMemoryManager::~HostDiscardableSharedMemoryManager() { | 191 DiscardableSharedMemoryManager::~DiscardableSharedMemoryManager() { |
188 base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider( | 192 base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider( |
189 this); | 193 this); |
190 } | 194 } |
191 | 195 |
192 HostDiscardableSharedMemoryManager* | 196 DiscardableSharedMemoryManager* DiscardableSharedMemoryManager::current() { |
193 HostDiscardableSharedMemoryManager::current() { | |
194 return g_discardable_shared_memory_manager.Pointer(); | 197 return g_discardable_shared_memory_manager.Pointer(); |
195 } | 198 } |
196 | 199 |
197 std::unique_ptr<base::DiscardableMemory> | 200 std::unique_ptr<base::DiscardableMemory> |
198 HostDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory( | 201 DiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(size_t size) { |
199 size_t size) { | |
200 DCHECK_NE(size, 0u); | 202 DCHECK_NE(size, 0u); |
201 | 203 |
202 DiscardableSharedMemoryId new_id = | 204 DiscardableSharedMemoryId new_id = |
203 g_next_discardable_shared_memory_id.GetNext(); | 205 g_next_discardable_shared_memory_id.GetNext(); |
204 base::ProcessHandle current_process_handle = base::GetCurrentProcessHandle(); | 206 base::ProcessHandle current_process_handle = base::GetCurrentProcessHandle(); |
205 | 207 |
206 // Note: Use DiscardableSharedMemoryHeap for in-process allocation | 208 // Note: Use DiscardableSharedMemoryHeap for in-process allocation |
207 // of discardable memory if the cost of each allocation is too high. | 209 // of discardable memory if the cost of each allocation is too high. |
208 base::SharedMemoryHandle handle; | 210 base::SharedMemoryHandle handle; |
209 AllocateLockedDiscardableSharedMemory(current_process_handle, | 211 AllocateLockedDiscardableSharedMemory( |
210 ChildProcessHost::kInvalidUniqueID, | 212 current_process_handle, kInvalidUniqueClientID, size, new_id, &handle); |
211 size, new_id, &handle); | |
212 std::unique_ptr<base::DiscardableSharedMemory> memory( | 213 std::unique_ptr<base::DiscardableSharedMemory> memory( |
213 new base::DiscardableSharedMemory(handle)); | 214 new base::DiscardableSharedMemory(handle)); |
214 if (!memory->Map(size)) | 215 if (!memory->Map(size)) |
215 base::TerminateBecauseOutOfMemory(size); | 216 base::TerminateBecauseOutOfMemory(size); |
216 // Close file descriptor to avoid running out. | 217 // Close file descriptor to avoid running out. |
217 memory->Close(); | 218 memory->Close(); |
218 return base::MakeUnique<DiscardableMemoryImpl>( | 219 return base::MakeUnique<DiscardableMemoryImpl>( |
219 std::move(memory), | 220 std::move(memory), |
220 base::Bind( | 221 base::Bind( |
221 &HostDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory, | 222 &DiscardableSharedMemoryManager::DeletedDiscardableSharedMemory, |
222 base::Unretained(this), new_id, ChildProcessHost::kInvalidUniqueID)); | 223 base::Unretained(this), new_id, kInvalidUniqueClientID)); |
223 } | 224 } |
224 | 225 |
225 bool HostDiscardableSharedMemoryManager::OnMemoryDump( | 226 bool DiscardableSharedMemoryManager::OnMemoryDump( |
226 const base::trace_event::MemoryDumpArgs& args, | 227 const base::trace_event::MemoryDumpArgs& args, |
227 base::trace_event::ProcessMemoryDump* pmd) { | 228 base::trace_event::ProcessMemoryDump* pmd) { |
228 if (args.level_of_detail == | 229 if (args.level_of_detail == |
229 base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) { | 230 base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) { |
230 base::trace_event::MemoryAllocatorDump* total_dump = | 231 base::trace_event::MemoryAllocatorDump* total_dump = |
231 pmd->CreateAllocatorDump("discardable"); | 232 pmd->CreateAllocatorDump("discardable"); |
232 total_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize, | 233 total_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize, |
233 base::trace_event::MemoryAllocatorDump::kUnitsBytes, | 234 base::trace_event::MemoryAllocatorDump::kUnitsBytes, |
234 GetBytesAllocated()); | 235 GetBytesAllocated()); |
235 return true; | 236 return true; |
(...skipping 23 matching lines...) Expand all Loading... |
259 dump->AddScalar( | 260 dump->AddScalar( |
260 "locked_size", base::trace_event::MemoryAllocatorDump::kUnitsBytes, | 261 "locked_size", base::trace_event::MemoryAllocatorDump::kUnitsBytes, |
261 segment->memory()->IsMemoryLocked() ? segment->memory()->mapped_size() | 262 segment->memory()->IsMemoryLocked() ? segment->memory()->mapped_size() |
262 : 0u); | 263 : 0u); |
263 | 264 |
264 // Create the cross-process ownership edge. If the child creates a | 265 // Create the cross-process ownership edge. If the child creates a |
265 // corresponding dump for the same segment, this will avoid to | 266 // corresponding dump for the same segment, this will avoid to |
266 // double-count them in tracing. If, instead, no other process will emit a | 267 // double-count them in tracing. If, instead, no other process will emit a |
267 // dump with the same guid, the segment will be accounted to the browser. | 268 // dump with the same guid, the segment will be accounted to the browser. |
268 const uint64_t child_tracing_process_id = | 269 const uint64_t child_tracing_process_id = |
269 ChildProcessHostImpl::ChildProcessUniqueIdToTracingProcessId( | 270 ClientIdToClientTracingId(child_process_id); |
270 child_process_id); | |
271 base::trace_event::MemoryAllocatorDumpGuid shared_segment_guid = | 271 base::trace_event::MemoryAllocatorDumpGuid shared_segment_guid = |
272 DiscardableSharedMemoryHeap::GetSegmentGUIDForTracing( | 272 DiscardableSharedMemoryHeap::GetSegmentGUIDForTracing( |
273 child_tracing_process_id, segment_id); | 273 child_tracing_process_id, segment_id); |
274 pmd->CreateSharedGlobalAllocatorDump(shared_segment_guid); | 274 pmd->CreateSharedGlobalAllocatorDump(shared_segment_guid); |
275 pmd->AddOwnershipEdge(dump->guid(), shared_segment_guid); | 275 pmd->AddOwnershipEdge(dump->guid(), shared_segment_guid); |
276 | 276 |
277 #if defined(COUNT_RESIDENT_BYTES_SUPPORTED) | 277 #if defined(COUNT_RESIDENT_BYTES_SUPPORTED) |
278 if (args.level_of_detail == | 278 if (args.level_of_detail == |
279 base::trace_event::MemoryDumpLevelOfDetail::DETAILED) { | 279 base::trace_event::MemoryDumpLevelOfDetail::DETAILED) { |
280 size_t resident_size = | 280 size_t resident_size = |
281 base::trace_event::ProcessMemoryDump::CountResidentBytes( | 281 base::trace_event::ProcessMemoryDump::CountResidentBytes( |
282 segment->memory()->memory(), segment->memory()->mapped_size()); | 282 segment->memory()->memory(), segment->memory()->mapped_size()); |
283 | 283 |
284 // This is added to the global dump since it has to be attributed to | 284 // This is added to the global dump since it has to be attributed to |
285 // both the allocator dumps involved. | 285 // both the allocator dumps involved. |
286 pmd->GetSharedGlobalAllocatorDump(shared_segment_guid) | 286 pmd->GetSharedGlobalAllocatorDump(shared_segment_guid) |
287 ->AddScalar("resident_size", | 287 ->AddScalar("resident_size", |
288 base::trace_event::MemoryAllocatorDump::kUnitsBytes, | 288 base::trace_event::MemoryAllocatorDump::kUnitsBytes, |
289 static_cast<uint64_t>(resident_size)); | 289 static_cast<uint64_t>(resident_size)); |
290 } | 290 } |
291 #endif // defined(COUNT_RESIDENT_BYTES_SUPPORTED) | 291 #endif // defined(COUNT_RESIDENT_BYTES_SUPPORTED) |
292 } | 292 } |
293 } | 293 } |
294 return true; | 294 return true; |
295 } | 295 } |
296 | 296 |
297 void HostDiscardableSharedMemoryManager:: | 297 void DiscardableSharedMemoryManager:: |
298 AllocateLockedDiscardableSharedMemoryForChild( | 298 AllocateLockedDiscardableSharedMemoryForChild( |
299 base::ProcessHandle process_handle, | 299 base::ProcessHandle process_handle, |
300 int child_process_id, | 300 int child_process_id, |
301 size_t size, | 301 size_t size, |
302 DiscardableSharedMemoryId id, | 302 DiscardableSharedMemoryId id, |
303 base::SharedMemoryHandle* shared_memory_handle) { | 303 base::SharedMemoryHandle* shared_memory_handle) { |
304 AllocateLockedDiscardableSharedMemory(process_handle, child_process_id, size, | 304 AllocateLockedDiscardableSharedMemory(process_handle, child_process_id, size, |
305 id, shared_memory_handle); | 305 id, shared_memory_handle); |
306 } | 306 } |
307 | 307 |
308 void HostDiscardableSharedMemoryManager::ChildDeletedDiscardableSharedMemory( | 308 void DiscardableSharedMemoryManager::ChildDeletedDiscardableSharedMemory( |
309 DiscardableSharedMemoryId id, | 309 DiscardableSharedMemoryId id, |
310 int child_process_id) { | 310 int child_process_id) { |
311 DeletedDiscardableSharedMemory(id, child_process_id); | 311 DeletedDiscardableSharedMemory(id, child_process_id); |
312 } | 312 } |
313 | 313 |
314 void HostDiscardableSharedMemoryManager::ProcessRemoved(int child_process_id) { | 314 void DiscardableSharedMemoryManager::ProcessRemoved(int child_process_id) { |
315 base::AutoLock lock(lock_); | 315 base::AutoLock lock(lock_); |
316 | 316 |
317 ProcessMap::iterator process_it = processes_.find(child_process_id); | 317 ProcessMap::iterator process_it = processes_.find(child_process_id); |
318 if (process_it == processes_.end()) | 318 if (process_it == processes_.end()) |
319 return; | 319 return; |
320 | 320 |
321 size_t bytes_allocated_before_releasing_memory = bytes_allocated_; | 321 size_t bytes_allocated_before_releasing_memory = bytes_allocated_; |
322 | 322 |
323 for (auto& segment_it : process_it->second) | 323 for (auto& segment_it : process_it->second) |
324 ReleaseMemory(segment_it.second->memory()); | 324 ReleaseMemory(segment_it.second->memory()); |
325 | 325 |
326 processes_.erase(process_it); | 326 processes_.erase(process_it); |
327 | 327 |
328 if (bytes_allocated_ != bytes_allocated_before_releasing_memory) | 328 if (bytes_allocated_ != bytes_allocated_before_releasing_memory) |
329 BytesAllocatedChanged(bytes_allocated_); | 329 BytesAllocatedChanged(bytes_allocated_); |
330 } | 330 } |
331 | 331 |
332 void HostDiscardableSharedMemoryManager::SetMemoryLimit(size_t limit) { | 332 void DiscardableSharedMemoryManager::SetMemoryLimit(size_t limit) { |
333 base::AutoLock lock(lock_); | 333 base::AutoLock lock(lock_); |
334 | 334 |
335 memory_limit_ = limit; | 335 memory_limit_ = limit; |
336 ReduceMemoryUsageUntilWithinMemoryLimit(); | 336 ReduceMemoryUsageUntilWithinMemoryLimit(); |
337 } | 337 } |
338 | 338 |
339 void HostDiscardableSharedMemoryManager::EnforceMemoryPolicy() { | 339 void DiscardableSharedMemoryManager::EnforceMemoryPolicy() { |
340 base::AutoLock lock(lock_); | 340 base::AutoLock lock(lock_); |
341 | 341 |
342 enforce_memory_policy_pending_ = false; | 342 enforce_memory_policy_pending_ = false; |
343 ReduceMemoryUsageUntilWithinMemoryLimit(); | 343 ReduceMemoryUsageUntilWithinMemoryLimit(); |
344 } | 344 } |
345 | 345 |
346 size_t HostDiscardableSharedMemoryManager::GetBytesAllocated() { | 346 size_t DiscardableSharedMemoryManager::GetBytesAllocated() { |
347 base::AutoLock lock(lock_); | 347 base::AutoLock lock(lock_); |
348 | 348 |
349 return bytes_allocated_; | 349 return bytes_allocated_; |
350 } | 350 } |
351 | 351 |
352 void HostDiscardableSharedMemoryManager::OnMemoryStateChange( | 352 void DiscardableSharedMemoryManager::OnMemoryStateChange( |
353 base::MemoryState state) { | 353 base::MemoryState state) { |
354 switch (state) { | 354 switch (state) { |
355 case base::MemoryState::NORMAL: | 355 case base::MemoryState::NORMAL: |
356 SetMemoryLimit(default_memory_limit_); | 356 SetMemoryLimit(default_memory_limit_); |
357 break; | 357 break; |
358 case base::MemoryState::THROTTLED: | 358 case base::MemoryState::THROTTLED: |
359 SetMemoryLimit(0); | 359 SetMemoryLimit(0); |
360 break; | 360 break; |
361 case base::MemoryState::SUSPENDED: | 361 case base::MemoryState::SUSPENDED: |
362 // Note that SUSPENDED never occurs in the main browser process so far. | 362 // Note that SUSPENDED never occurs in the main browser process so far. |
363 // Fall through. | 363 // Fall through. |
364 case base::MemoryState::UNKNOWN: | 364 case base::MemoryState::UNKNOWN: |
365 NOTREACHED(); | 365 NOTREACHED(); |
366 break; | 366 break; |
367 } | 367 } |
368 } | 368 } |
369 | 369 |
370 void HostDiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory( | 370 void DiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory( |
371 base::ProcessHandle process_handle, | 371 base::ProcessHandle process_handle, |
372 int client_process_id, | 372 int client_process_id, |
373 size_t size, | 373 size_t size, |
374 DiscardableSharedMemoryId id, | 374 DiscardableSharedMemoryId id, |
375 base::SharedMemoryHandle* shared_memory_handle) { | 375 base::SharedMemoryHandle* shared_memory_handle) { |
376 base::AutoLock lock(lock_); | 376 base::AutoLock lock(lock_); |
377 | 377 |
378 // Make sure |id| is not already in use. | 378 // Make sure |id| is not already in use. |
379 MemorySegmentMap& process_segments = processes_[client_process_id]; | 379 MemorySegmentMap& process_segments = processes_[client_process_id]; |
380 if (process_segments.find(id) != process_segments.end()) { | 380 if (process_segments.find(id) != process_segments.end()) { |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
425 | 425 |
426 scoped_refptr<MemorySegment> segment(new MemorySegment(std::move(memory))); | 426 scoped_refptr<MemorySegment> segment(new MemorySegment(std::move(memory))); |
427 process_segments[id] = segment.get(); | 427 process_segments[id] = segment.get(); |
428 segments_.push_back(segment.get()); | 428 segments_.push_back(segment.get()); |
429 std::push_heap(segments_.begin(), segments_.end(), CompareMemoryUsageTime); | 429 std::push_heap(segments_.begin(), segments_.end(), CompareMemoryUsageTime); |
430 | 430 |
431 if (bytes_allocated_ > memory_limit_) | 431 if (bytes_allocated_ > memory_limit_) |
432 ScheduleEnforceMemoryPolicy(); | 432 ScheduleEnforceMemoryPolicy(); |
433 } | 433 } |
434 | 434 |
435 void HostDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory( | 435 void DiscardableSharedMemoryManager::DeletedDiscardableSharedMemory( |
436 DiscardableSharedMemoryId id, | 436 DiscardableSharedMemoryId id, |
437 int client_process_id) { | 437 int client_process_id) { |
438 base::AutoLock lock(lock_); | 438 base::AutoLock lock(lock_); |
439 | 439 |
440 MemorySegmentMap& process_segments = processes_[client_process_id]; | 440 MemorySegmentMap& process_segments = processes_[client_process_id]; |
441 | 441 |
442 MemorySegmentMap::iterator segment_it = process_segments.find(id); | 442 MemorySegmentMap::iterator segment_it = process_segments.find(id); |
443 if (segment_it == process_segments.end()) { | 443 if (segment_it == process_segments.end()) { |
444 LOG(ERROR) << "Invalid discardable shared memory ID"; | 444 LOG(ERROR) << "Invalid discardable shared memory ID"; |
445 return; | 445 return; |
446 } | 446 } |
447 | 447 |
448 size_t bytes_allocated_before_releasing_memory = bytes_allocated_; | 448 size_t bytes_allocated_before_releasing_memory = bytes_allocated_; |
449 | 449 |
450 ReleaseMemory(segment_it->second->memory()); | 450 ReleaseMemory(segment_it->second->memory()); |
451 | 451 |
452 process_segments.erase(segment_it); | 452 process_segments.erase(segment_it); |
453 | 453 |
454 if (bytes_allocated_ != bytes_allocated_before_releasing_memory) | 454 if (bytes_allocated_ != bytes_allocated_before_releasing_memory) |
455 BytesAllocatedChanged(bytes_allocated_); | 455 BytesAllocatedChanged(bytes_allocated_); |
456 } | 456 } |
457 | 457 |
458 void HostDiscardableSharedMemoryManager::OnMemoryPressure( | 458 void DiscardableSharedMemoryManager::OnMemoryPressure( |
459 base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) { | 459 base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) { |
460 base::AutoLock lock(lock_); | 460 base::AutoLock lock(lock_); |
461 | 461 |
462 switch (memory_pressure_level) { | 462 switch (memory_pressure_level) { |
463 case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE: | 463 case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE: |
464 break; | 464 break; |
465 case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE: | 465 case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE: |
466 // Purge memory until usage is within half of |memory_limit_|. | 466 // Purge memory until usage is within half of |memory_limit_|. |
467 ReduceMemoryUsageUntilWithinLimit(memory_limit_ / 2); | 467 ReduceMemoryUsageUntilWithinLimit(memory_limit_ / 2); |
468 break; | 468 break; |
469 case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL: | 469 case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL: |
470 // Purge everything possible when pressure is critical. | 470 // Purge everything possible when pressure is critical. |
471 ReduceMemoryUsageUntilWithinLimit(0); | 471 ReduceMemoryUsageUntilWithinLimit(0); |
472 break; | 472 break; |
473 } | 473 } |
474 } | 474 } |
475 | 475 |
476 void | 476 void DiscardableSharedMemoryManager::ReduceMemoryUsageUntilWithinMemoryLimit() { |
477 HostDiscardableSharedMemoryManager::ReduceMemoryUsageUntilWithinMemoryLimit() { | |
478 lock_.AssertAcquired(); | 477 lock_.AssertAcquired(); |
479 | 478 |
480 if (bytes_allocated_ <= memory_limit_) | 479 if (bytes_allocated_ <= memory_limit_) |
481 return; | 480 return; |
482 | 481 |
483 ReduceMemoryUsageUntilWithinLimit(memory_limit_); | 482 ReduceMemoryUsageUntilWithinLimit(memory_limit_); |
484 if (bytes_allocated_ > memory_limit_) | 483 if (bytes_allocated_ > memory_limit_) |
485 ScheduleEnforceMemoryPolicy(); | 484 ScheduleEnforceMemoryPolicy(); |
486 } | 485 } |
487 | 486 |
488 void HostDiscardableSharedMemoryManager::ReduceMemoryUsageUntilWithinLimit( | 487 void DiscardableSharedMemoryManager::ReduceMemoryUsageUntilWithinLimit( |
489 size_t limit) { | 488 size_t limit) { |
490 TRACE_EVENT1("renderer_host", | 489 TRACE_EVENT1("renderer_host", |
491 "HostDiscardableSharedMemoryManager::" | 490 "DiscardableSharedMemoryManager::" |
492 "ReduceMemoryUsageUntilWithinLimit", | 491 "ReduceMemoryUsageUntilWithinLimit", |
493 "bytes_allocated", | 492 "bytes_allocated", bytes_allocated_); |
494 bytes_allocated_); | |
495 | 493 |
496 // Usage time of currently locked segments are updated to this time and | 494 // Usage time of currently locked segments are updated to this time and |
497 // we stop eviction attempts as soon as we come across a segment that we've | 495 // we stop eviction attempts as soon as we come across a segment that we've |
498 // previously tried to evict but was locked. | 496 // previously tried to evict but was locked. |
499 base::Time current_time = Now(); | 497 base::Time current_time = Now(); |
500 | 498 |
501 lock_.AssertAcquired(); | 499 lock_.AssertAcquired(); |
502 size_t bytes_allocated_before_purging = bytes_allocated_; | 500 size_t bytes_allocated_before_purging = bytes_allocated_; |
503 while (!segments_.empty()) { | 501 while (!segments_.empty()) { |
504 if (bytes_allocated_ <= limit) | 502 if (bytes_allocated_ <= limit) |
(...skipping 22 matching lines...) Expand all Loading... |
527 // Add memory segment (with updated usage timestamp) back on heap after | 525 // Add memory segment (with updated usage timestamp) back on heap after |
528 // failed attempt to purge it. | 526 // failed attempt to purge it. |
529 segments_.push_back(segment.get()); | 527 segments_.push_back(segment.get()); |
530 std::push_heap(segments_.begin(), segments_.end(), CompareMemoryUsageTime); | 528 std::push_heap(segments_.begin(), segments_.end(), CompareMemoryUsageTime); |
531 } | 529 } |
532 | 530 |
533 if (bytes_allocated_ != bytes_allocated_before_purging) | 531 if (bytes_allocated_ != bytes_allocated_before_purging) |
534 BytesAllocatedChanged(bytes_allocated_); | 532 BytesAllocatedChanged(bytes_allocated_); |
535 } | 533 } |
536 | 534 |
537 void HostDiscardableSharedMemoryManager::ReleaseMemory( | 535 void DiscardableSharedMemoryManager::ReleaseMemory( |
538 base::DiscardableSharedMemory* memory) { | 536 base::DiscardableSharedMemory* memory) { |
539 lock_.AssertAcquired(); | 537 lock_.AssertAcquired(); |
540 | 538 |
541 size_t size = memory->mapped_size(); | 539 size_t size = memory->mapped_size(); |
542 DCHECK_GE(bytes_allocated_, size); | 540 DCHECK_GE(bytes_allocated_, size); |
543 bytes_allocated_ -= size; | 541 bytes_allocated_ -= size; |
544 | 542 |
545 // This will unmap the memory segment and drop our reference. The result | 543 // This will unmap the memory segment and drop our reference. The result |
546 // is that the memory will be released to the OS if the child process is | 544 // is that the memory will be released to the OS if the child process is |
547 // no longer referencing it. | 545 // no longer referencing it. |
548 // Note: We intentionally leave the segment in the |segments| vector to | 546 // Note: We intentionally leave the segment in the |segments| vector to |
549 // avoid reconstructing the heap. The element will be removed from the heap | 547 // avoid reconstructing the heap. The element will be removed from the heap |
550 // when its last usage time is older than all other segments. | 548 // when its last usage time is older than all other segments. |
551 memory->Unmap(); | 549 memory->Unmap(); |
552 memory->Close(); | 550 memory->Close(); |
553 } | 551 } |
554 | 552 |
555 void HostDiscardableSharedMemoryManager::BytesAllocatedChanged( | 553 void DiscardableSharedMemoryManager::BytesAllocatedChanged( |
556 size_t new_bytes_allocated) const { | 554 size_t new_bytes_allocated) const { |
557 static const char kTotalDiscardableMemoryAllocatedKey[] = | 555 static const char kTotalDiscardableMemoryAllocatedKey[] = |
558 "total-discardable-memory-allocated"; | 556 "total-discardable-memory-allocated"; |
559 base::debug::SetCrashKeyValue(kTotalDiscardableMemoryAllocatedKey, | 557 base::debug::SetCrashKeyValue(kTotalDiscardableMemoryAllocatedKey, |
560 base::Uint64ToString(new_bytes_allocated)); | 558 base::Uint64ToString(new_bytes_allocated)); |
561 } | 559 } |
562 | 560 |
563 base::Time HostDiscardableSharedMemoryManager::Now() const { | 561 base::Time DiscardableSharedMemoryManager::Now() const { |
564 return base::Time::Now(); | 562 return base::Time::Now(); |
565 } | 563 } |
566 | 564 |
567 void HostDiscardableSharedMemoryManager::ScheduleEnforceMemoryPolicy() { | 565 void DiscardableSharedMemoryManager::ScheduleEnforceMemoryPolicy() { |
568 lock_.AssertAcquired(); | 566 lock_.AssertAcquired(); |
569 | 567 |
570 if (enforce_memory_policy_pending_) | 568 if (enforce_memory_policy_pending_) |
571 return; | 569 return; |
572 | 570 |
573 enforce_memory_policy_pending_ = true; | 571 enforce_memory_policy_pending_ = true; |
574 DCHECK(enforce_memory_policy_task_runner_); | 572 DCHECK(enforce_memory_policy_task_runner_); |
575 enforce_memory_policy_task_runner_->PostDelayedTask( | 573 enforce_memory_policy_task_runner_->PostDelayedTask( |
576 FROM_HERE, enforce_memory_policy_callback_, | 574 FROM_HERE, enforce_memory_policy_callback_, |
577 base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs)); | 575 base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs)); |
578 } | 576 } |
579 | 577 |
580 } // namespace content | 578 } // namespace discardable_memory |
OLD | NEW |