GPU Program Caching

content/common/gpu/gpu_channel.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CONTENT_COMMON_GPU_GPU_CHANNEL_H_
 #define CONTENT_COMMON_GPU_GPU_CHANNEL_H_
 #pragma once
 
 #include <deque>
 #include <string>
@@ skipping 17 matching lines @@
 struct GPUCreateCommandBufferConfig;
 class GpuWatchdog;
 
 namespace base {
 class MessageLoopProxy;
 class WaitableEvent;
 }
 
 namespace gpu {
 struct RefCountedCounter;
+class ShaderCache;

[greggman, 2012/06/15 08:10:24]

Should these be named ProgramCache and MemoryProgramCache? If we ever decide to
share shaders or if it's ever possible to cache shaders instead of programs it
will be awkward no?

[dmurph, 2012/06/19 01:08:33]

Done.

 }
 
 // Encapsulates an IPC channel between the GPU process and one renderer
 // process. On the renderer side there's a corresponding GpuChannelHost.
 class GpuChannel : public IPC::Channel::Listener,
                    public IPC::Message::Sender,
                    public base::RefCountedThreadSafe<GpuChannel> {
  public:
   // Takes ownership of the renderer process handle.
   GpuChannel(GpuChannelManager* gpu_channel_manager,
              GpuWatchdog* watchdog,
              gfx::GLShareGroup* share_group,
              gpu::gles2::MailboxManager* mailbox_manager,
              int client_id,
-             bool software);
+             bool software,
+             base::WeakPtr<gpu::ShaderCache> shader_cache);
 
   bool Init(base::MessageLoopProxy* io_message_loop,
             base::WaitableEvent* shutdown_event);
 
   // Get the GpuChannelManager that owns this channel.
   GpuChannelManager* gpu_channel_manager() const {
     return gpu_channel_manager_;
   }
 
   // Returns the name of the associated IPC channel.
@@ skipping 71 matching lines @@
       const gfx::Size& size,
       const GPUCreateCommandBufferConfig& init_params,
       IPC::Message* reply_message);
   void OnDestroyCommandBuffer(int32 route_id, IPC::Message* reply_message);
 
   // The lifetime of objects of this class is managed by a GpuChannelManager.
   // The GpuChannelManager destroy all the GpuChannels that they own when they
   // are destroyed. So a raw pointer is safe.
   GpuChannelManager* gpu_channel_manager_;
 
+  base::WeakPtr<gpu::ShaderCache> shader_cache_;

[greggman, 2012/06/15 08:10:24]

Does this really need to be a weak ptr? Usually we'd just use a raw* (see
gpu_channel_manager_ above) or we'd use a scoped_refptr if we needed it to be
ref counted. But I suspect under the current design the GpuChannelManager always
out lives the channels so it seems like these should just be raw pointers?

[dmurph, 2012/06/15 16:40:23]

Yes, but I would argue that it's
1. Better design, shows that we don't own the cache
2. The 'if (cache)' checks allow us to also define the shader cache as NULL to
disable it.
So it has the side effect of facilitating a disabled cache (if the gpu doesn't
support the right extensions) in the fastest way possible

+
   scoped_ptr<IPC::SyncChannel> channel_;
 
   // Number of routed messages for pending processing on a stub.
   scoped_refptr<gpu::RefCountedCounter> unprocessed_messages_;
 
   // If non-NULL, all stubs on this channel should stop processing GL
   // commands (via their GpuScheduler) when preempt_by_counter_->count
   // is non-zero.
   scoped_refptr<gpu::RefCountedCounter> preempt_by_counter_;
 
@@ skipping 25 matching lines @@
   bool software_;
   bool handle_messages_scheduled_;
   bool processed_get_state_fast_;
 
   base::WeakPtrFactory<GpuChannel> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuChannel);
 };
 
 #endif  // CONTENT_COMMON_GPU_GPU_CHANNEL_H_