src/gpu/command_buffer/service/async_pixel_transfer_manager_idle.cc

   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 #include "gpu/command_buffer/service/async_pixel_transfer_manager_idle.h"
   6
   7 #include "base/bind.h"
   8 #include "base/debug/trace_event.h"
   9 #include "base/debug/trace_event_synthetic_delay.h"
  10 #include "base/lazy_instance.h"
  11 #include "base/memory/weak_ptr.h"
  12 #include "ui/gl/scoped_binders.h"
  13
  14 namespace gpu {
  15
  16 namespace {
  17
  18 static uint64 g_next_pixel_transfer_state_id = 1;
  19
  20 void PerformNotifyCompletion(
  21     AsyncMemoryParams mem_params,
  22     scoped_refptr<AsyncPixelTransferCompletionObserver> observer) {
  23   TRACE_EVENT0("gpu", "PerformNotifyCompletion");
  24   observer->DidComplete(mem_params);
  25 }
  26
  27 }  // namespace
  28
  29 // Class which handles async pixel transfers in a platform
  30 // independent way.
  31 class AsyncPixelTransferDelegateIdle
  32     : public AsyncPixelTransferDelegate,
  33       public base::SupportsWeakPtr<AsyncPixelTransferDelegateIdle> {
  34  public:
  35   AsyncPixelTransferDelegateIdle(
  36       AsyncPixelTransferManagerIdle::SharedState* state,
  37       GLuint texture_id,
  38       const AsyncTexImage2DParams& define_params);
  39   ~AsyncPixelTransferDelegateIdle() override;
  40
  41   // Implement AsyncPixelTransferDelegate:
  42   void AsyncTexImage2D(const AsyncTexImage2DParams& tex_params,
  43                        const AsyncMemoryParams& mem_params,
  44                        const base::Closure& bind_callback) override;
  45   void AsyncTexSubImage2D(const AsyncTexSubImage2DParams& tex_params,
  46                           const AsyncMemoryParams& mem_params) override;
  47   bool TransferIsInProgress() override;
  48   void WaitForTransferCompletion() override;
  49
  50  private:
  51   void PerformAsyncTexImage2D(AsyncTexImage2DParams tex_params,
  52                               AsyncMemoryParams mem_params,
  53                               const base::Closure& bind_callback);
  54   void PerformAsyncTexSubImage2D(AsyncTexSubImage2DParams tex_params,
  55                                  AsyncMemoryParams mem_params);
  56
  57   uint64 id_;
  58   GLuint texture_id_;
  59   bool transfer_in_progress_;
  60   AsyncTexImage2DParams define_params_;
  61
  62   // Safe to hold a raw pointer because SharedState is owned by the Manager
  63   // which owns the Delegate.
  64   AsyncPixelTransferManagerIdle::SharedState* shared_state_;
  65
  66   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateIdle);
  67 };
  68
  69 AsyncPixelTransferDelegateIdle::AsyncPixelTransferDelegateIdle(
  70     AsyncPixelTransferManagerIdle::SharedState* shared_state,
  71     GLuint texture_id,
  72     const AsyncTexImage2DParams& define_params)
  73     : id_(g_next_pixel_transfer_state_id++),
  74       texture_id_(texture_id),
  75       transfer_in_progress_(false),
  76       define_params_(define_params),
  77       shared_state_(shared_state) {}
  78
  79 AsyncPixelTransferDelegateIdle::~AsyncPixelTransferDelegateIdle() {}
  80
  81 void AsyncPixelTransferDelegateIdle::AsyncTexImage2D(
  82     const AsyncTexImage2DParams& tex_params,
  83     const AsyncMemoryParams& mem_params,
  84     const base::Closure& bind_callback) {
  85   TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
  86   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
  87
  88   shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task(
  89       id_,
  90       this,
  91       base::Bind(&AsyncPixelTransferDelegateIdle::PerformAsyncTexImage2D,
  92                  AsWeakPtr(),
  93                  tex_params,
  94                  mem_params,
  95                  bind_callback)));
  96
  97   transfer_in_progress_ = true;
  98 }
  99
 100 void AsyncPixelTransferDelegateIdle::AsyncTexSubImage2D(
 101     const AsyncTexSubImage2DParams& tex_params,
 102     const AsyncMemoryParams& mem_params) {
 103   TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
 104   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
 105
 106   shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task(
 107       id_,
 108       this,
 109       base::Bind(&AsyncPixelTransferDelegateIdle::PerformAsyncTexSubImage2D,
 110                  AsWeakPtr(),
 111                  tex_params,
 112                  mem_params)));
 113
 114   transfer_in_progress_ = true;
 115 }
 116
 117 bool  AsyncPixelTransferDelegateIdle::TransferIsInProgress() {
 118   return transfer_in_progress_;
 119 }
 120
 121 void AsyncPixelTransferDelegateIdle::WaitForTransferCompletion() {
 122   for (std::list<AsyncPixelTransferManagerIdle::Task>::iterator iter =
 123            shared_state_->tasks.begin();
 124        iter != shared_state_->tasks.end();
 125        ++iter) {
 126     if (iter->transfer_id != id_)
 127       continue;
 128
 129     (*iter).task.Run();
 130     shared_state_->tasks.erase(iter);
 131     break;
 132   }
 133
 134   shared_state_->ProcessNotificationTasks();
 135 }
 136
 137 void AsyncPixelTransferDelegateIdle::PerformAsyncTexImage2D(
 138     AsyncTexImage2DParams tex_params,
 139     AsyncMemoryParams mem_params,
 140     const base::Closure& bind_callback) {
 141   TRACE_EVENT2("gpu", "PerformAsyncTexImage2D",
 142                "width", tex_params.width,
 143                "height", tex_params.height);
 144
 145   void* data = mem_params.GetDataAddress();
 146
 147   base::TimeTicks begin_time(base::TimeTicks::HighResNow());
 148   gfx::ScopedTextureBinder texture_binder(tex_params.target, texture_id_);
 149
 150   {
 151     TRACE_EVENT0("gpu", "glTexImage2D");
 152     glTexImage2D(
 153         tex_params.target,
 154         tex_params.level,
 155         tex_params.internal_format,
 156         tex_params.width,
 157         tex_params.height,
 158         tex_params.border,
 159         tex_params.format,
 160         tex_params.type,
 161         data);
 162   }
 163
 164   TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage");
 165   transfer_in_progress_ = false;
 166   shared_state_->texture_upload_count++;
 167   shared_state_->total_texture_upload_time +=
 168       base::TimeTicks::HighResNow() - begin_time;
 169
 170   // The texture is already fully bound so just call it now.
 171   bind_callback.Run();
 172 }
 173
 174 void AsyncPixelTransferDelegateIdle::PerformAsyncTexSubImage2D(
 175     AsyncTexSubImage2DParams tex_params,
 176     AsyncMemoryParams mem_params) {
 177   TRACE_EVENT2("gpu", "PerformAsyncTexSubImage2D",
 178                "width", tex_params.width,
 179                "height", tex_params.height);
 180
 181   void* data = mem_params.GetDataAddress();
 182
 183   base::TimeTicks begin_time(base::TimeTicks::HighResNow());
 184   gfx::ScopedTextureBinder texture_binder(tex_params.target, texture_id_);
 185
 186   // If it's a full texture update, use glTexImage2D as it's faster.
 187   // TODO(epenner): Make this configurable (http://crbug.com/259924)
 188   if (tex_params.xoffset == 0 &&
 189       tex_params.yoffset == 0 &&
 190       tex_params.target == define_params_.target &&
 191       tex_params.level  == define_params_.level &&
 192       tex_params.width  == define_params_.width &&
 193       tex_params.height == define_params_.height) {
 194     TRACE_EVENT0("gpu", "glTexImage2D");
 195     glTexImage2D(
 196         define_params_.target,
 197         define_params_.level,
 198         define_params_.internal_format,
 199         define_params_.width,
 200         define_params_.height,
 201         define_params_.border,
 202         tex_params.format,
 203         tex_params.type,
 204         data);
 205   } else {
 206     TRACE_EVENT0("gpu", "glTexSubImage2D");
 207     glTexSubImage2D(
 208         tex_params.target,
 209         tex_params.level,
 210         tex_params.xoffset,
 211         tex_params.yoffset,
 212         tex_params.width,
 213         tex_params.height,
 214         tex_params.format,
 215         tex_params.type,
 216         data);
 217   }
 218
 219   TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage");
 220   transfer_in_progress_ = false;
 221   shared_state_->texture_upload_count++;
 222   shared_state_->total_texture_upload_time +=
 223       base::TimeTicks::HighResNow() - begin_time;
 224 }
 225
 226 AsyncPixelTransferManagerIdle::Task::Task(
 227     uint64 transfer_id,
 228     AsyncPixelTransferDelegate* delegate,
 229     const base::Closure& task)
 230     : transfer_id(transfer_id),
 231       delegate(delegate),
 232       task(task) {
 233 }
 234
 235 AsyncPixelTransferManagerIdle::Task::~Task() {}
 236
 237 AsyncPixelTransferManagerIdle::SharedState::SharedState()
 238     : texture_upload_count(0) {}
 239
 240 AsyncPixelTransferManagerIdle::SharedState::~SharedState() {}
 241
 242 void AsyncPixelTransferManagerIdle::SharedState::ProcessNotificationTasks() {
 243   while (!tasks.empty()) {
 244     // Stop when we reach a pixel transfer task.
 245     if (tasks.front().transfer_id)
 246       return;
 247
 248     tasks.front().task.Run();
 249     tasks.pop_front();
 250   }
 251 }
 252
 253 AsyncPixelTransferManagerIdle::AsyncPixelTransferManagerIdle()
 254   : shared_state_() {
 255 }
 256
 257 AsyncPixelTransferManagerIdle::~AsyncPixelTransferManagerIdle() {}
 258
 259 void AsyncPixelTransferManagerIdle::BindCompletedAsyncTransfers() {
 260   // Everything is already bound.
 261 }
 262
 263 void AsyncPixelTransferManagerIdle::AsyncNotifyCompletion(
 264     const AsyncMemoryParams& mem_params,
 265     AsyncPixelTransferCompletionObserver* observer) {
 266   if (shared_state_.tasks.empty()) {
 267     observer->DidComplete(mem_params);
 268     return;
 269   }
 270
 271   shared_state_.tasks.push_back(
 272       Task(0,  // 0 transfer_id for notification tasks.
 273            NULL,
 274            base::Bind(
 275                &PerformNotifyCompletion,
 276                mem_params,
 277                make_scoped_refptr(observer))));
 278 }
 279
 280 uint32 AsyncPixelTransferManagerIdle::GetTextureUploadCount() {
 281   return shared_state_.texture_upload_count;
 282 }
 283
 284 base::TimeDelta AsyncPixelTransferManagerIdle::GetTotalTextureUploadTime() {
 285   return shared_state_.total_texture_upload_time;
 286 }
 287
 288 void AsyncPixelTransferManagerIdle::ProcessMorePendingTransfers() {
 289   if (shared_state_.tasks.empty())
 290     return;
 291
 292   // First task should always be a pixel transfer task.
 293   DCHECK(shared_state_.tasks.front().transfer_id);
 294   shared_state_.tasks.front().task.Run();
 295   shared_state_.tasks.pop_front();
 296
 297   shared_state_.ProcessNotificationTasks();
 298 }
 299
 300 bool AsyncPixelTransferManagerIdle::NeedsProcessMorePendingTransfers() {
 301   return !shared_state_.tasks.empty();
 302 }
 303
 304 void AsyncPixelTransferManagerIdle::WaitAllAsyncTexImage2D() {
 305   if (shared_state_.tasks.empty())
 306     return;
 307
 308   const Task& task = shared_state_.tasks.back();
 309   if (task.delegate)
 310     task.delegate->WaitForTransferCompletion();
 311 }
 312
 313 AsyncPixelTransferDelegate*
 314 AsyncPixelTransferManagerIdle::CreatePixelTransferDelegateImpl(
 315     gles2::TextureRef* ref,
 316     const AsyncTexImage2DParams& define_params) {
 317   return new AsyncPixelTransferDelegateIdle(&shared_state_,
 318                                             ref->service_id(),
 319                                             define_params);
 320 }
 321
 322 }  // namespace gpu