[go: nahoru, domu]
Google Git
Sign in
chromium / chromium / src / ab9bd16e5d42893cbe1bbb0a87ea2d5173d1e36d / . / gpu / ipc / service / gpu_channel_manager.h
blob: 7b9c9925744aa3da31e6141d279d7e8d48ff4cce [file] [log] [blame]
Avi Drissman05dfbc822022-09-13 21:25:34[diff] [blame]1// Copyright 2012 The Chromium Authors
apatrick@chromium.org7a31f7c2011-03-21 23:22:04[diff] [blame]2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
markdittmerd88b8352016-04-08 15:28:45[diff] [blame]5#ifndef GPU_IPC_SERVICE_GPU_CHANNEL_MANAGER_H_
6#define GPU_IPC_SERVICE_GPU_CHANNEL_MANAGER_H_
apatrick@chromium.org7a31f7c2011-03-21 23:22:04[diff] [blame]7
avia9aa7a82015-12-25 03:06:31[diff] [blame]8#include <stdint.h>
9
mostynb6682b1c42016-04-19 10:17:30[diff] [blame]10#include <memory>
dsinclair@chromium.orge3932abb2013-03-13 00:01:37[diff] [blame]11#include <string>
dmurph@chromium.org65dfc602012-07-23 20:39:39[diff] [blame]12#include <vector>
13
jonrossd2ca5e642019-10-16 12:08:52[diff] [blame]14#include "base/containers/flat_map.h"
Jamie Madill1dbe2a12017-07-05 17:49:36[diff] [blame]15#include "base/memory/memory_pressure_listener.h"
Keishi Hattori0e45c022021-11-27 09:25:52[diff] [blame]16#include "base/memory/raw_ptr.h"
levin@chromium.org3b63f8f42011-03-28 01:54:15[diff] [blame]17#include "base/memory/ref_counted.h"
dcheng@chromium.org35a5b752011-11-17 23:58:58[diff] [blame]18#include "base/memory/weak_ptr.h"
Ken Rockot509a26a2021-06-21 19:09:26[diff] [blame]19#include "base/process/process_handle.h"
Patrick Monette643cdf62021-10-15 19:13:42[diff] [blame]20#include "base/task/single_thread_task_runner.h"
Peng Huang7d2108cc2020-03-02 18:06:46[diff] [blame]21#include "base/threading/thread_checker.h"
Gabriel Charetted87f10f2022-03-31 00:44:22[diff] [blame]22#include "base/time/time.h"
Ken Rockot21735f92021-06-11 19:53:55[diff] [blame]23#include "base/unguessable_token.h"
apatrick@chromium.org7a31f7c2011-03-21 23:22:04[diff] [blame]24#include "build/build_config.h"
Benoit Lizefba2f792023-03-15 09:03:43[diff] [blame]25#include "components/viz/common/gpu/vulkan_context_provider.h"
fsamuela660ce02016-02-25 03:56:16[diff] [blame]26#include "gpu/command_buffer/common/constants.h"
Bo Liu01d003e42023-08-16 19:46:50[diff] [blame]27#include "gpu/command_buffer/common/shm_count.h"
Khushal7324ec42018-07-10 20:01:45[diff] [blame]28#include "gpu/command_buffer/service/gr_cache_controller.h"
Khushalc2667e32018-07-20 01:07:18[diff] [blame]29#include "gpu/command_buffer/service/gr_shader_cache.h"
jonrossd2ca5e642019-10-16 12:08:52[diff] [blame]30#include "gpu/command_buffer/service/memory_tracking.h"
Geoff Lang72fe4762018-10-19 15:11:36[diff] [blame]31#include "gpu/command_buffer/service/passthrough_discardable_manager.h"
ericrkdc5eeaa2017-05-19 02:23:50[diff] [blame]32#include "gpu/command_buffer/service/service_discardable_manager.h"
Peng Huangef396ff072022-10-12 18:00:56[diff] [blame]33#include "gpu/command_buffer/service/service_utils.h"
Antoine Labour6bf942492017-06-14 00:33:42[diff] [blame]34#include "gpu/command_buffer/service/shader_translator_cache.h"
Peng Huang8294a5a7f2019-01-23 18:56:26[diff] [blame]35#include "gpu/command_buffer/service/shared_context_state.h"
j.isorce265b2e562016-04-19 07:40:02[diff] [blame]36#include "gpu/config/gpu_driver_bug_workarounds.h"
ericrk41a1579e2017-02-10 20:56:28[diff] [blame]37#include "gpu/config/gpu_feature_info.h"
Jonathan Backer0af509962018-05-30 16:05:07[diff] [blame]38#include "gpu/config/gpu_preferences.h"
Loko Kung68b0fb2a2022-08-17 04:05:10[diff] [blame]39#include "gpu/ipc/common/gpu_disk_cache_type.h"
jonross1f2903d2020-03-06 13:59:40[diff] [blame]40#include "gpu/ipc/common/gpu_peak_memory.h"
Antoine Labour5f0b2672018-01-05 22:42:59[diff] [blame]41#include "gpu/ipc/service/gpu_ipc_service_export.h"
Anton Bikineevaabbd6082021-05-15 17:57:20[diff] [blame]42#include "third_party/abseil-cpp/absl/types/optional.h"
reveman510a6e02014-11-05 00:59:18[diff] [blame]43#include "ui/gfx/gpu_memory_buffer.h"
apatrick@chromium.org7a31f7c2011-03-21 23:22:04[diff] [blame]44#include "ui/gfx/native_widget_types.h"
hshi@chromium.orgb8673e62012-09-25 03:15:00[diff] [blame]45#include "ui/gl/gl_surface.h"
fsamuela660ce02016-02-25 03:56:16[diff] [blame]46#include "url/gurl.h"
apatrick@chromium.org7a31f7c2011-03-21 23:22:04[diff] [blame]47
Peng Huang91a82682023-06-21 02:59:10[diff] [blame]48namespace base::trace_event {
Jonathan Ross577b2762020-03-27 19:47:57[diff] [blame]49class TracedValue;
Peng Huang91a82682023-06-21 02:59:10[diff] [blame]50} // namespace base::trace_event
Jonathan Ross577b2762020-03-27 19:47:57[diff] [blame]51
Vikas Soni789e3162023-09-29 19:57:02[diff] [blame]52namespace gfx {
53struct GpuExtraInfo;
54}
55
kylechar7a463842016-05-26 14:46:12[diff] [blame]56namespace gl {
piman@chromium.orgd8d97c222012-03-08 01:31:28[diff] [blame]57class GLShareGroup;
58}
59
piman@chromium.org18fd41952012-06-06 00:09:46[diff] [blame]60namespace gpu {
piman@chromium.org18fd41952012-06-06 00:09:46[diff] [blame]61
Scott Violet833ff162023-04-19 00:32:31[diff] [blame]62class BuiltInShaderCacheWriter;
Peng Huang91a82682023-06-21 02:59:10[diff] [blame]63class DawnContextProvider;
64class ImageDecodeAcceleratorWorker;
Sunny Sachanandaniadddad72017-10-26 01:08:51[diff] [blame]65struct GpuPreferences;
thestig@chromium.org1c982712011-06-27 23:44:31[diff] [blame]66class GpuChannel;
fsamuela660ce02016-02-25 03:56:16[diff] [blame]67class GpuChannelManagerDelegate;
reveman@chromium.orgb63f1d62014-07-18 15:40:59[diff] [blame]68class GpuMemoryBufferFactory;
sadrul2fb7e152016-08-30 05:21:45[diff] [blame]69class GpuWatchdogThread;
Antoine Labour40b0ca42018-01-03 20:15:34[diff] [blame]70class MailboxManager;
Sunny Sachanandaniadddad72017-10-26 01:08:51[diff] [blame]71class Scheduler;
Peng Huang91a82682023-06-21 02:59:10[diff] [blame]72class SharedImageManager;
Sunny Sachanandaniadddad72017-10-26 01:08:51[diff] [blame]73class SyncPointManager;
Antoine Labour3b79a442018-07-06 20:19:34[diff] [blame]74struct VideoMemoryUsageStats;
Sunny Sachanandaniadddad72017-10-26 01:08:51[diff] [blame]75
76namespace gles2 {
Sunny Sachanandaniadddad72017-10-26 01:08:51[diff] [blame]77class Outputter;
78class ProgramCache;
79} // namespace gles2
apatrick@chromium.org2dcf7022011-04-15 19:20:41[diff] [blame]80
Loko Kung6fb05ef2022-08-20 00:33:50[diff] [blame]81namespace webgpu {
82class DawnCachingInterfaceFactory;
83} // namespace webgpu
84
apatrick@chromium.orgf24a1e2b2011-04-08 01:48:48[diff] [blame]85// A GpuChannelManager is a thread responsible for issuing rendering commands
86// managing the lifetimes of GPU channels and forwarding IPC requests from the
87// browser process to them based on the corresponding renderer ID.
Khushalc2667e32018-07-20 01:07:18[diff] [blame]88class GPU_IPC_SERVICE_EXPORT GpuChannelManager
89 : public raster::GrShaderCache::Client {
apatrick@chromium.org7a31f7c2011-03-21 23:22:04[diff] [blame]90 public:
Vikas Soni532d7382021-06-14 19:02:19[diff] [blame]91 using OnMemoryAllocatedChangeCallback =
92 base::OnceCallback<void(gpu::CommandBufferId id,
93 uint64_t old_size,
94 uint64_t new_size,
95 gpu::GpuPeakMemoryAllocationSource source)>;
96
Vikas Soni34cb2c72018-11-07 21:21:25[diff] [blame]97 GpuChannelManager(
98 const GpuPreferences& gpu_preferences,
99 GpuChannelManagerDelegate* delegate,
100 GpuWatchdogThread* watchdog,
101 scoped_refptr<base::SingleThreadTaskRunner> task_runner,
102 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
103 Scheduler* scheduler,
104 SyncPointManager* sync_point_manager,
Peng Huange3b8c1d2019-03-05 17:21:12[diff] [blame]105 SharedImageManager* shared_image_manager,
Vikas Soni34cb2c72018-11-07 21:21:25[diff] [blame]106 GpuMemoryBufferFactory* gpu_memory_buffer_factory,
107 const GpuFeatureInfo& gpu_feature_info,
Bo Liu01d003e42023-08-16 19:46:50[diff] [blame]108 GpuProcessShmCount use_shader_cache_shm_count,
Vikas Soni34cb2c72018-11-07 21:21:25[diff] [blame]109 scoped_refptr<gl::GLSurface> default_offscreen_surface,
Andres Calderon Jaramilloc8c27692018-12-11 01:38:37[diff] [blame]110 ImageDecodeAcceleratorWorker* image_decode_accelerator_worker,
Christopher Cameron4f7ce362019-04-26 02:21:37[diff] [blame]111 viz::VulkanContextProvider* vulkan_context_provider = nullptr,
Sean Gilhuly86026152019-11-06 16:00:16[diff] [blame]112 viz::MetalContextProvider* metal_context_provider = nullptr,
Peng Huang91a82682023-06-21 02:59:10[diff] [blame]113 DawnContextProvider* dawn_context_provider = nullptr,
114 webgpu::DawnCachingInterfaceFactory* dawn_caching_interface_factory =
115 nullptr);
Peter Boströmdbacdc22021-09-23 22:11:46[diff] [blame]116
117 GpuChannelManager(const GpuChannelManager&) = delete;
118 GpuChannelManager& operator=(const GpuChannelManager&) = delete;
119
Khushalc2667e32018-07-20 01:07:18[diff] [blame]120 ~GpuChannelManager() override;
fsamuela660ce02016-02-25 03:56:16[diff] [blame]121
122 GpuChannelManagerDelegate* delegate() const { return delegate_; }
Antoine Labour6bf942492017-06-14 00:33:42[diff] [blame]123 GpuWatchdogThread* watchdog() const { return watchdog_; }
fsamuela660ce02016-02-25 03:56:16[diff] [blame]124
Vikas Soni789e3162023-09-29 19:57:02[diff] [blame]125 GpuChannel* EstablishChannel(
126 const base::UnguessableToken& channel_token,
127 int client_id,
128 uint64_t client_tracing_id,
129 bool is_gpu_host,
130 const gfx::GpuExtraInfo& gpu_extra_info,
131 gpu::GpuMemoryBufferFactory* gpu_memory_buffer_factory);
fsamuel27d230cc2016-03-21 19:25:06[diff] [blame]132
Ken Rockot509a26a2021-06-21 19:09:26[diff] [blame]133 void SetChannelClientPid(int client_id, base::ProcessId client_pid);
Loko Kung68b0fb2a2022-08-17 04:05:10[diff] [blame]134 void SetChannelDiskCacheHandle(int client_id,
135 const gpu::GpuDiskCacheHandle& handle);
Loko Kungc46bd1952022-08-18 09:37:34[diff] [blame]136 void OnDiskCacheHandleDestoyed(const gpu::GpuDiskCacheHandle& handle);
Ken Rockot509a26a2021-06-21 19:09:26[diff] [blame]137
Loko Kung68b0fb2a2022-08-17 04:05:10[diff] [blame]138 void PopulateCache(const gpu::GpuDiskCacheHandle& handle,
139 const std::string& key,
140 const std::string& program);
kylechar2fde6782023-01-04 17:22:42[diff] [blame]141 void DestroyGpuMemoryBuffer(gfx::GpuMemoryBufferId id, int client_id);
Xiaohan Wangfa22d3e2022-01-15 02:02:43[diff] [blame]142#if BUILDFLAG(IS_ANDROID)
fsamuela660ce02016-02-25 03:56:16[diff] [blame]143 void WakeUpGpu();
144#endif
145 void DestroyAllChannels();
apatrick@chromium.org7a31f7c2011-03-21 23:22:04[diff] [blame]146
147 // Remove the channel for a particular renderer.
piman@chromium.orge608ce02012-01-12 22:30:07[diff] [blame]148 void RemoveChannel(int client_id);
apatrick@chromium.org7a31f7c2011-03-21 23:22:04[diff] [blame]149
Colin Blundell4eb430e72023-06-01 15:28:09[diff] [blame]150 void OnContextLost(int context_lost_count,
151 bool synthetic_loss,
152 error::ContextLostReason context_lost_reason);
amarinichev@chromium.org0fc35742011-04-13 17:57:54[diff] [blame]153
sunnyps41a6a15a2017-03-31 00:38:54[diff] [blame]154 const GpuPreferences& gpu_preferences() const { return gpu_preferences_; }
j.isorce265b2e562016-04-19 07:40:02[diff] [blame]155 const GpuDriverBugWorkarounds& gpu_driver_bug_workarounds() const {
156 return gpu_driver_bug_workarounds_;
157 }
ericrk41a1579e2017-02-10 20:56:28[diff] [blame]158 const GpuFeatureInfo& gpu_feature_info() const { return gpu_feature_info_; }
Antoine Labour6bf942492017-06-14 00:33:42[diff] [blame]159 ServiceDiscardableManager* discardable_manager() {
160 return &discardable_manager_;
161 }
Geoff Lang72fe4762018-10-19 15:11:36[diff] [blame]162 PassthroughDiscardableManager* passthrough_discardable_manager() {
163 return &passthrough_discardable_manager_;
164 }
Chandan Padhi07f05c02017-09-19 02:52:53[diff] [blame]165 gles2::Outputter* outputter();
markdittmerd88b8352016-04-08 15:28:45[diff] [blame]166 gles2::ProgramCache* program_cache();
Antoine Labour6bf942492017-06-14 00:33:42[diff] [blame]167 gles2::ShaderTranslatorCache* shader_translator_cache() {
168 return &shader_translator_cache_;
169 }
170 gles2::FramebufferCompletenessCache* framebuffer_completeness_cache() {
171 return &framebuffer_completeness_cache_;
172 }
dmurph@chromium.org65dfc602012-07-23 20:39:39[diff] [blame]173
avia9aa7a82015-12-25 03:06:31[diff] [blame]174 GpuChannel* LookupChannel(int32_t client_id) const;
backer@chromium.org538195f2011-09-08 15:03:20[diff] [blame]175
Eric Karl304eff12018-07-27 21:13:35[diff] [blame]176 gl::GLSurface* default_offscreen_surface() const {
177 return default_offscreen_surface_.get();
178 }
hshi@chromium.orgb8673e62012-09-25 03:15:00[diff] [blame]179
reveman@chromium.orgb63f1d62014-07-18 15:40:59[diff] [blame]180 GpuMemoryBufferFactory* gpu_memory_buffer_factory() {
reveman611d024f2015-06-25 22:42:40[diff] [blame]181 return gpu_memory_buffer_factory_;
reveman@chromium.orgb63f1d62014-07-18 15:40:59[diff] [blame]182 }
183
jonrossd2ca5e642019-10-16 12:08:52[diff] [blame]184 MemoryTracker::Observer* peak_memory_monitor() {
185 return &peak_memory_monitor_;
186 }
187
Bo Liu01d003e42023-08-16 19:46:50[diff] [blame]188 GpuProcessShmCount* use_shader_cache_shm_count() {
189 return &use_shader_cache_shm_count_;
190 }
Vikas Soni532d7382021-06-14 19:02:19[diff] [blame]191
Xiaohan Wangfa22d3e2022-01-15 02:02:43[diff] [blame]192#if BUILDFLAG(IS_ANDROID)
pimanfa4f2542015-09-24 07:45:16[diff] [blame]193 void DidAccessGpu();
Khushalcbaac9b2018-07-10 06:00:45[diff] [blame]194 void OnBackgroundCleanup();
pimanfa4f2542015-09-24 07:45:16[diff] [blame]195#endif
196
Khushalcbaac9b2018-07-10 06:00:45[diff] [blame]197 void OnApplicationBackgrounded();
Benoit Lizefba2f792023-03-15 09:03:43[diff] [blame]198 void OnApplicationForegounded();
199 bool application_backgrounded() const { return application_backgrounded_; }
200 // Make sure that delayed cleanup is happening now. Expensive.
201 void PerformImmediateCleanup();
Khushalcbaac9b2018-07-10 06:00:45[diff] [blame]202
Vikas Soni532d7382021-06-14 19:02:19[diff] [blame]203 MailboxManager* mailbox_manager() const { return mailbox_manager_.get(); }
fsamueledc0c2c2016-11-18 22:28:04[diff] [blame]204
205 gl::GLShareGroup* share_group() const { return share_group_.get(); }
206
sunnyps8f9139e2017-05-12 17:53:25[diff] [blame]207 SyncPointManager* sync_point_manager() const { return sync_point_manager_; }
208
Vikas Soni532d7382021-06-14 19:02:19[diff] [blame]209 SharedImageManager* shared_image_manager() const {
210 return shared_image_manager_;
211 }
Eric Karl8a6cc1662018-10-09 22:23:50[diff] [blame]212
Peng Huangef396ff072022-10-12 18:00:56[diff] [blame]213 bool use_passthrough_cmd_decoder() const {
214 return gpu_preferences_.use_passthrough_cmd_decoder &&
215 gles2::PassthroughCommandDecoderSupported();
216 }
217
Antoine Labour3b79a442018-07-06 20:19:34[diff] [blame]218 // Retrieve GPU Resource consumption statistics for the task manager
219 void GetVideoMemoryUsageStats(
220 VideoMemoryUsageStats* video_memory_usage_stats) const;
221
jonrossd2ca5e642019-10-16 12:08:52[diff] [blame]222 // Starts tracking the peak memory across all MemoryTrackers for
223 // |sequence_num|. Repeated calls with the same value are ignored.
224 void StartPeakMemoryMonitor(uint32_t sequence_num);
225
jonross1f2903d2020-03-06 13:59:40[diff] [blame]226 // Ends the tracking for |sequence_num| and returns the peak memory per
227 // allocation source. Along with the total |out_peak_memory|.
228 base::flat_map<GpuPeakMemoryAllocationSource, uint64_t> GetPeakMemoryUsage(
229 uint32_t sequence_num,
230 uint64_t* out_peak_memory);
jonrossd2ca5e642019-10-16 12:08:52[diff] [blame]231
Peng Huang20361dad12019-01-23 14:48:10[diff] [blame]232 scoped_refptr<SharedContextState> GetSharedContextState(
Khushalb2c140b2018-07-09 20:21:16[diff] [blame]233 ContextResult* result);
Khushal7324ec42018-07-10 20:01:45[diff] [blame]234 void ScheduleGrContextCleanup();
Khushalc2667e32018-07-20 01:07:18[diff] [blame]235 raster::GrShaderCache* gr_shader_cache() {
236 return gr_shader_cache_ ? &*gr_shader_cache_ : nullptr;
237 }
238
Loko Kung6fb05ef2022-08-20 00:33:50[diff] [blame]239 webgpu::DawnCachingInterfaceFactory* dawn_caching_interface_factory() {
240 return dawn_caching_interface_factory_.get();
241 }
Loko Kung6fb05ef2022-08-20 00:33:50[diff] [blame]242
Khushalc2667e32018-07-20 01:07:18[diff] [blame]243 // raster::GrShaderCache::Client implementation.
244 void StoreShader(const std::string& key, const std::string& shader) override;
Khushalb2c140b2018-07-09 20:21:16[diff] [blame]245
Andres Calderon Jaramilloc8c27692018-12-11 01:38:37[diff] [blame]246 void SetImageDecodeAcceleratorWorkerForTesting(
247 ImageDecodeAcceleratorWorker* worker);
248
kylecharf9148cfb2019-07-22 23:12:07[diff] [blame]249 void LoseAllContexts();
250
Vikas Soni532d7382021-06-14 19:02:19[diff] [blame]251 SharedContextState::ContextLostCallback GetContextLostCallback();
252 GpuChannelManager::OnMemoryAllocatedChangeCallback
253 GetOnMemoryAllocatedChangeCallback();
254
Jonathan Backer700a1c25812018-12-03 22:44:42[diff] [blame]255 private:
jonrossd2ca5e642019-10-16 12:08:52[diff] [blame]256 friend class GpuChannelManagerTest;
257
258 // Observes changes in GPU memory, and tracks the peak usage for clients. The
259 // client is responsible for providing a unique |sequence_num| for each time
260 // period in which it wishes to track memory usage.
261 class GPU_IPC_SERVICE_EXPORT GpuPeakMemoryMonitor
262 : public MemoryTracker::Observer {
263 public:
Jonathan Rossa228c562020-07-28 21:51:55[diff] [blame]264 GpuPeakMemoryMonitor(
265 GpuChannelManager* channel_manager,
266 scoped_refptr<base::SingleThreadTaskRunner> task_runner);
Peter Boströmdbacdc22021-09-23 22:11:46[diff] [blame]267
268 GpuPeakMemoryMonitor(const GpuPeakMemoryMonitor&) = delete;
269 GpuPeakMemoryMonitor& operator=(const GpuPeakMemoryMonitor&) = delete;
270
jonrossd2ca5e642019-10-16 12:08:52[diff] [blame]271 ~GpuPeakMemoryMonitor() override;
272
jonross1f2903d2020-03-06 13:59:40[diff] [blame]273 base::flat_map<GpuPeakMemoryAllocationSource, uint64_t> GetPeakMemoryUsage(
274 uint32_t sequence_num,
275 uint64_t* out_peak_memory);
jonrossd2ca5e642019-10-16 12:08:52[diff] [blame]276 void StartGpuMemoryTracking(uint32_t sequence_num);
277 void StopGpuMemoryTracking(uint32_t sequence_num);
278
jonross1f2903d2020-03-06 13:59:40[diff] [blame]279 base::WeakPtr<MemoryTracker::Observer> GetWeakPtr();
280 void InvalidateWeakPtrs();
281
jonrossd2ca5e642019-10-16 12:08:52[diff] [blame]282 private:
jonross1f2903d2020-03-06 13:59:40[diff] [blame]283 struct SequenceTracker {
284 public:
285 SequenceTracker(uint64_t current_memory,
286 base::flat_map<GpuPeakMemoryAllocationSource, uint64_t>
287 current_memory_per_source);
288 SequenceTracker(const SequenceTracker&);
289 ~SequenceTracker();
290
Jonathan Ross577b2762020-03-27 19:47:57[diff] [blame]291 uint64_t initial_memory_ = 0u;
jonross1f2903d2020-03-06 13:59:40[diff] [blame]292 uint64_t total_memory_ = 0u;
293 base::flat_map<GpuPeakMemoryAllocationSource, uint64_t>
Jonathan Ross577b2762020-03-27 19:47:57[diff] [blame]294 initial_memory_per_source_;
295 base::flat_map<GpuPeakMemoryAllocationSource, uint64_t>
jonross1f2903d2020-03-06 13:59:40[diff] [blame]296 peak_memory_per_source_;
297 };
Jonathan Ross577b2762020-03-27 19:47:57[diff] [blame]298 std::unique_ptr<base::trace_event::TracedValue> StartTrackingTracedValue();
299 std::unique_ptr<base::trace_event::TracedValue> StopTrackingTracedValue(
300 SequenceTracker& sequence);
jonrossd2ca5e642019-10-16 12:08:52[diff] [blame]301 // MemoryTracker::Observer:
jonross1f2903d2020-03-06 13:59:40[diff] [blame]302 void OnMemoryAllocatedChange(
303 CommandBufferId id,
304 uint64_t old_size,
305 uint64_t new_size,
306 GpuPeakMemoryAllocationSource source =
307 GpuPeakMemoryAllocationSource::UNKNOWN) override;
jonrossd2ca5e642019-10-16 12:08:52[diff] [blame]308
309 // Tracks all currently requested sequences mapped to the peak memory seen.
jonross1f2903d2020-03-06 13:59:40[diff] [blame]310 base::flat_map<uint32_t, SequenceTracker> sequence_trackers_;
jonrossd2ca5e642019-10-16 12:08:52[diff] [blame]311
312 // Tracks the total current memory across all MemoryTrackers.
313 uint64_t current_memory_ = 0u;
314
jonross1f2903d2020-03-06 13:59:40[diff] [blame]315 base::flat_map<GpuPeakMemoryAllocationSource, uint64_t>
316 current_memory_per_source_;
317
jonrossd2ca5e642019-10-16 12:08:52[diff] [blame]318 base::WeakPtrFactory<GpuPeakMemoryMonitor> weak_factory_;
jonrossd2ca5e642019-10-16 12:08:52[diff] [blame]319 };
320
Xiaohan Wangfa22d3e2022-01-15 02:02:43[diff] [blame]321#if BUILDFLAG(IS_ANDROID)
pimanfa4f2542015-09-24 07:45:16[diff] [blame]322 void ScheduleWakeUpGpu();
323 void DoWakeUpGpu();
324#endif
amarinichev@chromium.org0fc35742011-04-13 17:57:54[diff] [blame]325
Jamie Madill1dbe2a12017-07-05 17:49:36[diff] [blame]326 void HandleMemoryPressure(
327 base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
328
sunnyps41a6a15a2017-03-31 00:38:54[diff] [blame]329 // These objects manage channels to individual renderer processes. There is
330 // one channel for each renderer process that has connected to this GPU
331 // process.
Peng Huang7d2108cc2020-03-02 18:06:46[diff] [blame]332 base::flat_map<int32_t, std::unique_ptr<GpuChannel>> gpu_channels_;
sunnyps41a6a15a2017-03-31 00:38:54[diff] [blame]333
334 scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
335 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
336
sadrul3f8d0fa2016-09-08 17:47:41[diff] [blame]337 const GpuPreferences gpu_preferences_;
Zhenyao Mod4dba1052017-07-27 23:02:39[diff] [blame]338 const GpuDriverBugWorkarounds gpu_driver_bug_workarounds_;
penghuang7404df9882016-02-29 23:07:29[diff] [blame]339
Keishi Hattori0e45c022021-11-27 09:25:52[diff] [blame]340 const raw_ptr<GpuChannelManagerDelegate> delegate_;
sunnyps498edc202015-08-22 02:00:39[diff] [blame]341
Keishi Hattori0e45c022021-11-27 09:25:52[diff] [blame]342 raw_ptr<GpuWatchdogThread> watchdog_;
sunnyps498edc202015-08-22 02:00:39[diff] [blame]343
kylechar7a463842016-05-26 14:46:12[diff] [blame]344 scoped_refptr<gl::GLShareGroup> share_group_;
sunnyps8f9139e2017-05-12 17:53:25[diff] [blame]345
Scott Violet833ff162023-04-19 00:32:31[diff] [blame]346#if BUILDFLAG(IS_MAC)
347 std::unique_ptr<BuiltInShaderCacheWriter> shader_cache_writer_;
348#endif
349
Antoine Labour40b0ca42018-01-03 20:15:34[diff] [blame]350 std::unique_ptr<MailboxManager> mailbox_manager_;
Chandan Padhi07f05c02017-09-19 02:52:53[diff] [blame]351 std::unique_ptr<gles2::Outputter> outputter_;
Keishi Hattori0e45c022021-11-27 09:25:52[diff] [blame]352 raw_ptr<Scheduler> scheduler_;
boliuc5befe72015-07-21 19:08:56[diff] [blame]353 // SyncPointManager guaranteed to outlive running MessageLoop.
Keishi Hattori0e45c022021-11-27 09:25:52[diff] [blame]354 const raw_ptr<SyncPointManager> sync_point_manager_;
355 const raw_ptr<SharedImageManager> shared_image_manager_;
mostynb6682b1c42016-04-19 10:17:30[diff] [blame]356 std::unique_ptr<gles2::ProgramCache> program_cache_;
Antoine Labour6bf942492017-06-14 00:33:42[diff] [blame]357 gles2::ShaderTranslatorCache shader_translator_cache_;
358 gles2::FramebufferCompletenessCache framebuffer_completeness_cache_;
kylechar7a463842016-05-26 14:46:12[diff] [blame]359 scoped_refptr<gl::GLSurface> default_offscreen_surface_;
Keishi Hattori0e45c022021-11-27 09:25:52[diff] [blame]360 const raw_ptr<GpuMemoryBufferFactory> gpu_memory_buffer_factory_;
ericrk41a1579e2017-02-10 20:56:28[diff] [blame]361 GpuFeatureInfo gpu_feature_info_;
ericrkdc5eeaa2017-05-19 02:23:50[diff] [blame]362 ServiceDiscardableManager discardable_manager_;
Geoff Lang72fe4762018-10-19 15:11:36[diff] [blame]363 PassthroughDiscardableManager passthrough_discardable_manager_;
Xiaohan Wangfa22d3e2022-01-15 02:02:43[diff] [blame]364#if BUILDFLAG(IS_ANDROID)
pimanfa4f2542015-09-24 07:45:16[diff] [blame]365 // Last time we know the GPU was powered on. Global for tracking across all
366 // transport surfaces.
367 base::TimeTicks last_gpu_access_time_;
368 base::TimeTicks begin_wake_up_time_;
369#endif
apatrick@chromium.org7a31f7c2011-03-21 23:22:04[diff] [blame]370
Keishi Hattori0e45c022021-11-27 09:25:52[diff] [blame]371 raw_ptr<ImageDecodeAcceleratorWorker> image_decode_accelerator_worker_ =
372 nullptr;
Andres Calderon Jaramilloc8c27692018-12-11 01:38:37[diff] [blame]373
Bo Liu01d003e42023-08-16 19:46:50[diff] [blame]374 // A count in shared memory that's non-zero for the duration of loading
375 // shaders. Read by the browser process on GPU process crash.
376 GpuProcessShmCount use_shader_cache_shm_count_;
ericrk8c0b7bf62017-03-17 20:07:23[diff] [blame]377
Jamie Madill1dbe2a12017-07-05 17:49:36[diff] [blame]378 base::MemoryPressureListener memory_pressure_listener_;
379
Peng Huang20361dad12019-01-23 14:48:10[diff] [blame]380 // The SharedContextState is shared across all RasterDecoders. Note
Khushalb2c140b2018-07-09 20:21:16[diff] [blame]381 // that this class needs to be ref-counted to conveniently manage the lifetime
382 // of the shared context in the case of a context loss. While the
Khushalcbaac9b2018-07-10 06:00:45[diff] [blame]383 // GpuChannelManager strictly outlives the RasterDecoders, in the event of a
Khushalb2c140b2018-07-09 20:21:16[diff] [blame]384 // context loss the clients need to re-create the GpuChannel and command
385 // buffers once notified. In this interim state we can have multiple instances
Peng Huang20361dad12019-01-23 14:48:10[diff] [blame]386 // of the SharedContextState, for the lost and recovered clients. In
Khushalb2c140b2018-07-09 20:21:16[diff] [blame]387 // order to avoid having the GpuChannelManager keep the lost context state
388 // alive until all clients have recovered, we use a ref-counted object and
389 // allow the decoders to manage its lifetime.
Anton Bikineevaabbd6082021-05-15 17:57:20[diff] [blame]390 absl::optional<raster::GrShaderCache> gr_shader_cache_;
Peng Huang20361dad12019-01-23 14:48:10[diff] [blame]391 scoped_refptr<SharedContextState> shared_context_state_;
Khushalb2c140b2018-07-09 20:21:16[diff] [blame]392
Peng Huang91a82682023-06-21 02:59:10[diff] [blame]393 raw_ptr<webgpu::DawnCachingInterfaceFactory> dawn_caching_interface_factory_;
Loko Kung6fb05ef2022-08-20 00:33:50[diff] [blame]394
Christopher Cameron4f7ce362019-04-26 02:21:37[diff] [blame]395 // With --enable-vulkan, |vulkan_context_provider_| will be set from
Brian Ho4e84b172019-10-18 23:09:52[diff] [blame]396 // viz::GpuServiceImpl. The raster decoders will use it for rasterization if
Sean Gilhulyc8018df2020-01-21 18:20:35[diff] [blame]397 // features::Vulkan is used.
Keishi Hattori0e45c022021-11-27 09:25:52[diff] [blame]398 raw_ptr<viz::VulkanContextProvider> vulkan_context_provider_ = nullptr;
Peng Huang42c8a1d2018-10-30 18:28:14[diff] [blame]399
Sunny Sachanandanifb74c17f2023-04-10 21:29:17[diff] [blame]400 // If features::SkiaGraphite, |metal_context_provider_| will be set from
401 // viz::GpuServiceImpl. The raster decoders may use it for rasterization.
Keishi Hattori0e45c022021-11-27 09:25:52[diff] [blame]402 raw_ptr<viz::MetalContextProvider> metal_context_provider_ = nullptr;
Christopher Cameron4f7ce362019-04-26 02:21:37[diff] [blame]403
Sunny Sachanandanifb74c17f2023-04-10 21:29:17[diff] [blame]404 // With features::SkiaGraphite, |dawn_context_provider_| will be set from
405 // viz::GpuServiceImpl. The raster decoders may use it for rasterization.
Peng Huang632d1702023-06-16 14:51:10[diff] [blame]406 raw_ptr<DawnContextProvider> dawn_context_provider_ = nullptr;
Sean Gilhuly86026152019-11-06 16:00:16[diff] [blame]407
jonrossd2ca5e642019-10-16 12:08:52[diff] [blame]408 GpuPeakMemoryMonitor peak_memory_monitor_;
409
Peng Huang108cd402021-02-22 15:36:27[diff] [blame]410 // Creation time of GpuChannelManger.
411 const base::TimeTicks creation_time_ = base::TimeTicks::Now();
412
413 // Context lost time since creation of |GpuChannelManger|.
414 base::TimeDelta context_lost_time_;
415
416 // Count of context lost.
417 int context_lost_count_ = 0;
418
Benoit Lizefba2f792023-03-15 09:03:43[diff] [blame]419 bool application_backgrounded_ = false;
420
Peng Huang7d2108cc2020-03-02 18:06:46[diff] [blame]421 THREAD_CHECKER(thread_checker_);
422
mohan.reddyef206002014-09-12 06:38:21[diff] [blame]423 // Member variables should appear before the WeakPtrFactory, to ensure
424 // that any WeakPtrs to Controller are invalidated before its members
425 // variable's destructors are executed, rendering them invalid.
Jeremy Roman28926e92019-07-15 15:42:16[diff] [blame]426 base::WeakPtrFactory<GpuChannelManager> weak_factory_{this};
apatrick@chromium.org7a31f7c2011-03-21 23:22:04[diff] [blame]427};
428
markdittmerd88b8352016-04-08 15:28:45[diff] [blame]429} // namespace gpu
jam@chromium.orgeb398192012-10-22 20:16:19[diff] [blame]430
markdittmerd88b8352016-04-08 15:28:45[diff] [blame]431#endif // GPU_IPC_SERVICE_GPU_CHANNEL_MANAGER_H_