OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "content/common/gpu/gpu_memory_manager.h" | |
6 | |
7 #include <algorithm> | |
8 | |
9 #include "base/bind.h" | |
10 #include "base/command_line.h" | |
11 #include "base/message_loop/message_loop.h" | |
12 #include "base/process/process_handle.h" | |
13 #include "base/strings/string_number_conversions.h" | |
14 #include "base/trace_event/trace_event.h" | |
15 #include "content/common/gpu/gpu_channel_manager.h" | |
16 #include "content/common/gpu/gpu_channel_manager_delegate.h" | |
17 #include "content/common/gpu/gpu_memory_tracking.h" | |
18 #include "gpu/command_buffer/common/gpu_memory_allocation.h" | |
19 #include "gpu/command_buffer/service/gpu_switches.h" | |
20 #include "gpu/ipc/common/gpu_memory_uma_stats.h" | |
21 #include "gpu/ipc/common/memory_stats.h" | |
22 | |
23 using gpu::MemoryAllocation; | |
24 | |
25 namespace content { | |
26 namespace { | |
27 | |
28 const uint64_t kBytesAllocatedStep = 16 * 1024 * 1024; | |
29 | |
30 void TrackValueChanged(uint64_t old_size, | |
31 uint64_t new_size, | |
32 uint64_t* total_size) { | |
33 DCHECK(new_size > old_size || *total_size >= (old_size - new_size)); | |
34 *total_size += (new_size - old_size); | |
35 } | |
36 | |
37 } | |
38 | |
39 GpuMemoryManager::GpuMemoryManager(GpuChannelManager* channel_manager) | |
40 : channel_manager_(channel_manager), | |
41 bytes_allocated_current_(0), | |
42 bytes_allocated_historical_max_(0) {} | |
43 | |
44 GpuMemoryManager::~GpuMemoryManager() { | |
45 DCHECK(tracking_groups_.empty()); | |
46 DCHECK(!bytes_allocated_current_); | |
47 } | |
48 | |
49 void GpuMemoryManager::TrackMemoryAllocatedChange( | |
50 GpuMemoryTrackingGroup* tracking_group, | |
51 uint64_t old_size, | |
52 uint64_t new_size) { | |
53 TrackValueChanged(old_size, new_size, &tracking_group->size_); | |
54 TrackValueChanged(old_size, new_size, &bytes_allocated_current_); | |
55 | |
56 if (GetCurrentUsage() > bytes_allocated_historical_max_ + | |
57 kBytesAllocatedStep) { | |
58 bytes_allocated_historical_max_ = GetCurrentUsage(); | |
59 // If we're blowing into new memory usage territory, spam the browser | |
60 // process with the most up-to-date information about our memory usage. | |
61 SendUmaStatsToHost(); | |
62 } | |
63 } | |
64 | |
65 bool GpuMemoryManager::EnsureGPUMemoryAvailable(uint64_t /* size_needed */) { | |
66 // TODO: Check if there is enough space. Lose contexts until there is. | |
67 return true; | |
68 } | |
69 | |
70 uint64_t GpuMemoryManager::GetTrackerMemoryUsage( | |
71 gpu::gles2::MemoryTracker* tracker) const { | |
72 TrackingGroupMap::const_iterator tracking_group_it = | |
73 tracking_groups_.find(tracker); | |
74 DCHECK(tracking_group_it != tracking_groups_.end()); | |
75 return tracking_group_it->second->GetSize(); | |
76 } | |
77 | |
78 GpuMemoryTrackingGroup* GpuMemoryManager::CreateTrackingGroup( | |
79 base::ProcessId pid, gpu::gles2::MemoryTracker* memory_tracker) { | |
80 GpuMemoryTrackingGroup* tracking_group = new GpuMemoryTrackingGroup( | |
81 pid, memory_tracker, this); | |
82 DCHECK(!tracking_groups_.count(tracking_group->GetMemoryTracker())); | |
83 tracking_groups_.insert(std::make_pair(tracking_group->GetMemoryTracker(), | |
84 tracking_group)); | |
85 return tracking_group; | |
86 } | |
87 | |
88 void GpuMemoryManager::OnDestroyTrackingGroup( | |
89 GpuMemoryTrackingGroup* tracking_group) { | |
90 DCHECK(tracking_groups_.count(tracking_group->GetMemoryTracker())); | |
91 tracking_groups_.erase(tracking_group->GetMemoryTracker()); | |
92 } | |
93 | |
94 void GpuMemoryManager::GetVideoMemoryUsageStats( | |
95 gpu::VideoMemoryUsageStats* video_memory_usage_stats) const { | |
96 // For each context group, assign its memory usage to its PID | |
97 video_memory_usage_stats->process_map.clear(); | |
98 for (TrackingGroupMap::const_iterator i = | |
99 tracking_groups_.begin(); i != tracking_groups_.end(); ++i) { | |
100 const GpuMemoryTrackingGroup* tracking_group = i->second; | |
101 video_memory_usage_stats->process_map[ | |
102 tracking_group->GetPid()].video_memory += tracking_group->GetSize(); | |
103 } | |
104 | |
105 // Assign the total across all processes in the GPU process | |
106 video_memory_usage_stats->process_map[ | |
107 base::GetCurrentProcId()].video_memory = GetCurrentUsage(); | |
108 video_memory_usage_stats->process_map[ | |
109 base::GetCurrentProcId()].has_duplicates = true; | |
110 | |
111 video_memory_usage_stats->bytes_allocated = GetCurrentUsage(); | |
112 video_memory_usage_stats->bytes_allocated_historical_max = | |
113 bytes_allocated_historical_max_; | |
114 } | |
115 | |
116 void GpuMemoryManager::SendUmaStatsToHost() { | |
117 if (!channel_manager_) | |
118 return; | |
119 gpu::GPUMemoryUmaStats params; | |
120 params.bytes_allocated_current = GetCurrentUsage(); | |
121 params.bytes_allocated_max = bytes_allocated_historical_max_; | |
122 params.context_group_count = static_cast<uint32_t>(tracking_groups_.size()); | |
123 channel_manager_->delegate()->GpuMemoryUmaStats(params); | |
124 } | |
125 } // namespace content | |
OLD | NEW |