gpu/command_buffer/service/in_process_command_buffer.h

   1 // Copyright 2013 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 #ifndef GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
   6 #define GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
   7
   8 #include <map>
   9 #include <vector>
  10
  11 #include "base/atomic_sequence_num.h"
  12 #include "base/callback.h"
  13 #include "base/compiler_specific.h"
  14 #include "base/containers/scoped_ptr_hash_map.h"
  15 #include "base/memory/ref_counted.h"
  16 #include "base/memory/scoped_ptr.h"
  17 #include "base/memory/weak_ptr.h"
  18 #include "base/synchronization/lock.h"
  19 #include "base/synchronization/waitable_event.h"
  20 #include "base/threading/thread.h"
  21 #include "gpu/command_buffer/client/gpu_control.h"
  22 #include "gpu/command_buffer/common/command_buffer.h"
  23 #include "gpu/gpu_export.h"
  24 #include "ui/gfx/gpu_memory_buffer.h"
  25 #include "ui/gfx/native_widget_types.h"
  26 #include "ui/gl/gl_surface.h"
  27 #include "ui/gl/gpu_preference.h"
  28
  29 namespace base {
  30 class SequenceChecker;
  31 }
  32
  33 namespace gfx {
  34 class GLContext;
  35 class GLShareGroup;
  36 class GLSurface;
  37 class Size;
  38 }
  39
  40 #if defined(OS_ANDROID)
  41 namespace gfx {
  42 class SurfaceTexture;
  43 }
  44 namespace gpu {
  45 class StreamTextureManagerInProcess;
  46 }
  47 #endif
  48
  49 namespace gpu {
  50 class SyncPointManager;
  51 class ValueStateMap;
  52
  53 namespace gles2 {
  54 class FramebufferCompletenessCache;
  55 class GLES2Decoder;
  56 class MailboxManager;
  57 class ProgramCache;
  58 class ShaderTranslatorCache;
  59 class SubscriptionRefSet;
  60 }
  61
  62 class CommandBufferServiceBase;
  63 class GpuMemoryBufferManager;
  64 class GpuScheduler;
  65 class ImageFactory;
  66 class TransferBufferManagerInterface;
  67
  68 // This class provides a thread-safe interface to the global GPU service (for
  69 // example GPU thread) when being run in single process mode.
  70 // However, the behavior for accessing one context (i.e. one instance of this
  71 // class) from different client threads is undefined.
  72 class GPU_EXPORT InProcessCommandBuffer : public CommandBuffer,
  73                                           public GpuControl {
  74  public:
  75   class Service;
  76   explicit InProcessCommandBuffer(const scoped_refptr<Service>& service);
  77   ~InProcessCommandBuffer() override;
  78
  79   // If |surface| is not NULL, use it directly; in this case, the command
  80   // buffer gpu thread must be the same as the client thread. Otherwise create
  81   // a new GLSurface.
  82   bool Initialize(scoped_refptr<gfx::GLSurface> surface,
  83                   bool is_offscreen,
  84                   gfx::AcceleratedWidget window,
  85                   const gfx::Size& size,
  86                   const std::vector<int32>& attribs,
  87                   gfx::GpuPreference gpu_preference,
  88                   const base::Closure& context_lost_callback,
  89                   InProcessCommandBuffer* share_group,
  90                   GpuMemoryBufferManager* gpu_memory_buffer_manager,
  91                   ImageFactory* image_factory);
  92   void Destroy();
  93
  94   // CommandBuffer implementation:
  95   bool Initialize() override;
  96   State GetLastState() override;
  97   int32 GetLastToken() override;
  98   void Flush(int32 put_offset) override;
  99   void OrderingBarrier(int32 put_offset) override;
 100   void WaitForTokenInRange(int32 start, int32 end) override;
 101   void WaitForGetOffsetInRange(int32 start, int32 end) override;
 102   void SetGetBuffer(int32 shm_id) override;
 103   scoped_refptr<gpu::Buffer> CreateTransferBuffer(size_t size,
 104                                                   int32* id) override;
 105   void DestroyTransferBuffer(int32 id) override;
 106   gpu::error::Error GetLastError() override;
 107
 108   // GpuControl implementation:
 109   gpu::Capabilities GetCapabilities() override;
 110   int32 CreateImage(ClientBuffer buffer,
 111                     size_t width,
 112                     size_t height,
 113                     unsigned internalformat) override;
 114   void DestroyImage(int32 id) override;
 115   int32 CreateGpuMemoryBufferImage(size_t width,
 116                                    size_t height,
 117                                    unsigned internalformat,
 118                                    unsigned usage) override;
 119   uint32 InsertSyncPoint() override;
 120   uint32 InsertFutureSyncPoint() override;
 121   void RetireSyncPoint(uint32 sync_point) override;
 122   void SignalSyncPoint(uint32 sync_point,
 123                        const base::Closure& callback) override;
 124   void SignalQuery(uint32 query_id, const base::Closure& callback) override;
 125   void SetSurfaceVisible(bool visible) override;
 126   uint32 CreateStreamTexture(uint32 texture_id) override;
 127   void SetLock(base::Lock*) override;
 128   bool IsGpuChannelLost() override;
 129   CommandBufferNamespace GetNamespaceID() const override;
 130   uint64_t GetCommandBufferID() const override;
 131
 132   // The serializer interface to the GPU service (i.e. thread).
 133   class Service {
 134    public:
 135     Service();
 136     virtual ~Service();
 137
 138     virtual void AddRef() const = 0;
 139     virtual void Release() const = 0;
 140
 141     // Queues a task to run as soon as possible.
 142     virtual void ScheduleTask(const base::Closure& task) = 0;
 143
 144     // Schedules |callback| to run at an appropriate time for performing delayed
 145     // work.
 146     virtual void ScheduleDelayedWork(const base::Closure& task) = 0;
 147
 148     virtual bool UseVirtualizedGLContexts() = 0;
 149     virtual scoped_refptr<gles2::ShaderTranslatorCache>
 150         shader_translator_cache() = 0;
 151     virtual scoped_refptr<gles2::FramebufferCompletenessCache>
 152     framebuffer_completeness_cache() = 0;
 153     virtual SyncPointManager* sync_point_manager() = 0;
 154     scoped_refptr<gfx::GLShareGroup> share_group();
 155     scoped_refptr<gles2::MailboxManager> mailbox_manager();
 156     scoped_refptr<gles2::SubscriptionRefSet> subscription_ref_set();
 157     scoped_refptr<gpu::ValueStateMap> pending_valuebuffer_state();
 158     gpu::gles2::ProgramCache* program_cache();
 159
 160    private:
 161     scoped_refptr<gfx::GLShareGroup> share_group_;
 162     scoped_refptr<gles2::MailboxManager> mailbox_manager_;
 163     scoped_refptr<gles2::SubscriptionRefSet> subscription_ref_set_;
 164     scoped_refptr<gpu::ValueStateMap> pending_valuebuffer_state_;
 165     scoped_ptr<gpu::gles2::ProgramCache> program_cache_;
 166   };
 167
 168 #if defined(OS_ANDROID)
 169   scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture(
 170       uint32 stream_id);
 171 #endif
 172
 173  private:
 174   struct InitializeOnGpuThreadParams {
 175     bool is_offscreen;
 176     gfx::AcceleratedWidget window;
 177     const gfx::Size& size;
 178     const std::vector<int32>& attribs;
 179     gfx::GpuPreference gpu_preference;
 180     gpu::Capabilities* capabilities;  // Ouptut.
 181     InProcessCommandBuffer* context_group;
 182     ImageFactory* image_factory;
 183
 184     InitializeOnGpuThreadParams(bool is_offscreen,
 185                                 gfx::AcceleratedWidget window,
 186                                 const gfx::Size& size,
 187                                 const std::vector<int32>& attribs,
 188                                 gfx::GpuPreference gpu_preference,
 189                                 gpu::Capabilities* capabilities,
 190                                 InProcessCommandBuffer* share_group,
 191                                 ImageFactory* image_factory)
 192         : is_offscreen(is_offscreen),
 193           window(window),
 194           size(size),
 195           attribs(attribs),
 196           gpu_preference(gpu_preference),
 197           capabilities(capabilities),
 198           context_group(share_group),
 199           image_factory(image_factory) {}
 200   };
 201
 202   bool InitializeOnGpuThread(const InitializeOnGpuThreadParams& params);
 203   bool DestroyOnGpuThread();
 204   void FlushOnGpuThread(int32 put_offset);
 205   void ScheduleDelayedWorkOnGpuThread();
 206   uint32 CreateStreamTextureOnGpuThread(uint32 client_texture_id);
 207   bool MakeCurrent();
 208   base::Closure WrapCallback(const base::Closure& callback);
 209   State GetStateFast();
 210   void QueueTask(const base::Closure& task) { service_->ScheduleTask(task); }
 211   void CheckSequencedThread();
 212   void RetireSyncPointOnGpuThread(uint32 sync_point);
 213   void SignalSyncPointOnGpuThread(uint32 sync_point,
 214                                   const base::Closure& callback);
 215   bool WaitSyncPointOnGpuThread(uint32 sync_point);
 216   void SignalQueryOnGpuThread(unsigned query_id, const base::Closure& callback);
 217   void DestroyTransferBufferOnGpuThread(int32 id);
 218   void CreateImageOnGpuThread(int32 id,
 219                               const gfx::GpuMemoryBufferHandle& handle,
 220                               const gfx::Size& size,
 221                               gfx::BufferFormat format,
 222                               uint32 internalformat);
 223   void DestroyImageOnGpuThread(int32 id);
 224   void SetGetBufferOnGpuThread(int32 shm_id, base::WaitableEvent* completion);
 225
 226   // Callbacks:
 227   void OnContextLost();
 228   void OnResizeView(gfx::Size size, float scale_factor);
 229   bool GetBufferChanged(int32 transfer_buffer_id);
 230   void PumpCommands();
 231   void PerformDelayedWork();
 232
 233   const uint64_t command_buffer_id_;
 234
 235   // Members accessed on the gpu thread (possibly with the exception of
 236   // creation):
 237   bool context_lost_;
 238   scoped_refptr<TransferBufferManagerInterface> transfer_buffer_manager_;
 239   scoped_ptr<GpuScheduler> gpu_scheduler_;
 240   scoped_ptr<gles2::GLES2Decoder> decoder_;
 241   scoped_refptr<gfx::GLContext> context_;
 242   scoped_refptr<gfx::GLSurface> surface_;
 243   base::Closure context_lost_callback_;
 244   bool delayed_work_pending_;  // Used to throttle PerformDelayedWork.
 245   ImageFactory* image_factory_;
 246
 247   // Members accessed on the client thread:
 248   State last_state_;
 249   int32 last_put_offset_;
 250   gpu::Capabilities capabilities_;
 251   GpuMemoryBufferManager* gpu_memory_buffer_manager_;
 252   base::AtomicSequenceNumber next_image_id_;
 253
 254   // Accessed on both threads:
 255   scoped_ptr<CommandBufferServiceBase> command_buffer_;
 256   base::Lock command_buffer_lock_;
 257   base::WaitableEvent flush_event_;
 258   scoped_refptr<Service> service_;
 259   State state_after_last_flush_;
 260   base::Lock state_after_last_flush_lock_;
 261   scoped_refptr<gfx::GLShareGroup> gl_share_group_;
 262
 263 #if defined(OS_ANDROID)
 264   scoped_ptr<StreamTextureManagerInProcess> stream_texture_manager_;
 265 #endif
 266
 267   // Only used with explicit scheduling and the gpu thread is the same as
 268   // the client thread.
 269   scoped_ptr<base::SequenceChecker> sequence_checker_;
 270
 271   base::WeakPtr<InProcessCommandBuffer> gpu_thread_weak_ptr_;
 272   base::WeakPtrFactory<InProcessCommandBuffer> gpu_thread_weak_ptr_factory_;
 273
 274   DISALLOW_COPY_AND_ASSIGN(InProcessCommandBuffer);
 275 };
 276
 277 // Default Service class when a null service is used.
 278 class GPU_EXPORT GpuInProcessThread
 279     : public base::Thread,
 280       public NON_EXPORTED_BASE(InProcessCommandBuffer::Service),
 281       public base::RefCountedThreadSafe<GpuInProcessThread> {
 282  public:
 283   explicit GpuInProcessThread(SyncPointManager* sync_point_manager);
 284
 285   void AddRef() const override;
 286   void Release() const override;
 287   void ScheduleTask(const base::Closure& task) override;
 288   void ScheduleDelayedWork(const base::Closure& callback) override;
 289   bool UseVirtualizedGLContexts() override;
 290   scoped_refptr<gles2::ShaderTranslatorCache> shader_translator_cache()
 291       override;
 292   scoped_refptr<gles2::FramebufferCompletenessCache>
 293   framebuffer_completeness_cache() override;
 294   SyncPointManager* sync_point_manager() override;
 295
 296  private:
 297   ~GpuInProcessThread() override;
 298   friend class base::RefCountedThreadSafe<GpuInProcessThread>;
 299
 300   SyncPointManager* sync_point_manager_;  // Non-owning.
 301   scoped_refptr<gpu::gles2::ShaderTranslatorCache> shader_translator_cache_;
 302   scoped_refptr<gpu::gles2::FramebufferCompletenessCache>
 303       framebuffer_completeness_cache_;
 304   DISALLOW_COPY_AND_ASSIGN(GpuInProcessThread);
 305 };
 306
 307 }  // namespace gpu
 308
 309 #endif  // GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_