gpu: Report time spent performing async texture uploads.

ui/gl/async_pixel_transfer_delegate_android.cc

 // 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.
 
 #include "ui/gl/async_pixel_transfer_delegate_android.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 52 matching lines @@
     return NULL;
   scoped_ptr<SharedMemory> duped_shared_memory(
       new SharedMemory(duped_shared_memory_handle, false));
   // Map the shared memory into this process. This validates the size.
   if (!duped_shared_memory->Map(size))
     return NULL;
   return duped_shared_memory.release();
 }
 
 // Gets the address of the data from shared memory.
-void* GetAddress(SharedMemory* shared_memory,
-                 uint32 shm_size,
-                 uint32 shm_data_offset,
-                 uint32 shm_data_size) {
+void* GetAddress(SharedMemory* shared_memory, uint32 shm_data_offset) {
   // Memory bounds have already been validated, so there
   // is just DCHECKS here.
   DCHECK(shared_memory);
   DCHECK(shared_memory->memory());
-  DCHECK_LE(shm_data_offset + shm_data_size, shm_size);
   return static_cast<int8*>(shared_memory->memory()) + shm_data_offset;
 }
 
 class TransferThread : public base::Thread {
  public:
   TransferThread() : base::Thread(kAsyncTransferThreadName) {
     Start();
   }
   virtual ~TransferThread() {
     Stop();
@@ skipping 64 matching lines @@
     DCHECK_NE(EGL_NO_IMAGE_KHR, egl_image_);
     // We can only change the active texture and unit 0,
     // as that is all that will be restored.
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, texture_id_);
     glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, egl_image_);
     *bound_params = late_bind_define_params_;
     needs_late_bind_ = false;
   }
 
-  // Completion callbacks.
-  void TexImage2DCompleted() {
-    needs_late_bind_ = true;
-    transfer_in_progress_ = false;
-  }
-  void TexSubImage2DCompleted() {
-    transfer_in_progress_ = false;
-  }
-
-protected:
+ protected:
   friend class base::RefCountedThreadSafe<TransferStateInternal>;
   friend class AsyncPixelTransferDelegateAndroid;
 
   static void DeleteTexture(GLuint id) {
     glDeleteTextures(1, &id);
   }
 
   virtual ~TransferStateInternal() {
     if (egl_image_) {
       EGLDisplay display = eglGetCurrentDisplay();
@@ skipping 18 matching lines @@
   // Definition params for texture that needs binding.
   AsyncTexImage2DParams late_bind_define_params_;
 
   // Indicates that an async transfer is in progress.
   bool transfer_in_progress_;
 
   // It would be nice if we could just create a new EGLImage for
   // every upload, but I found that didn't work, so this stores
   // one for the lifetime of the texture.
   EGLImageKHR egl_image_;
+
+  // Time spent performing last transfer.
+  base::TimeDelta last_transfer_time_;
 };
 
 // Android needs thread-safe ref-counting, so this just wraps
 // an internal thread-safe ref-counted state object.
 class AsyncTransferStateAndroid : public AsyncPixelTransferState {
  public:
   explicit AsyncTransferStateAndroid(GLuint texture_id)
       : internal_(new TransferStateInternal(texture_id)) {
   }
   virtual ~AsyncTransferStateAndroid() {}
   virtual bool TransferIsInProgress() {
       return internal_->TransferIsInProgress();
   }
   virtual void BindTransfer(AsyncTexImage2DParams* bound_params) {
       internal_->BindTransfer(bound_params);
   }
   scoped_refptr<TransferStateInternal> internal_;
 };
 
 // Class which handles async pixel transfers on Android (using
 // EGLImageKHR and another upload thread)
-class AsyncPixelTransferDelegateAndroid : public AsyncPixelTransferDelegate {
+class AsyncPixelTransferDelegateAndroid
+    : public AsyncPixelTransferDelegate,
+      public base::SupportsWeakPtr<AsyncPixelTransferDelegateAndroid> {
  public:
-  AsyncPixelTransferDelegateAndroid() {}
-  virtual ~AsyncPixelTransferDelegateAndroid() {}
+  AsyncPixelTransferDelegateAndroid();
+  virtual ~AsyncPixelTransferDelegateAndroid();
 
   // implement AsyncPixelTransferDelegate:
   virtual void AsyncNotifyCompletion(
       const base::Closure& task) OVERRIDE;
   virtual void AsyncTexImage2D(
       AsyncPixelTransferState* state,
       const AsyncTexImage2DParams& tex_params,
       const AsyncMemoryParams& mem_params) OVERRIDE;
   virtual void AsyncTexSubImage2D(
       AsyncPixelTransferState* state,
       const AsyncTexSubImage2DParams& tex_params,
       const AsyncMemoryParams& mem_params) OVERRIDE;
+  virtual uint32 GetTextureUploadCount() OVERRIDE;
+  virtual base::TimeDelta GetTotalTextureUploadTime() OVERRIDE;
 
  private:
   // implement AsyncPixelTransferDelegate:
   virtual AsyncPixelTransferState*
       CreateRawPixelTransferState(GLuint texture_id) OVERRIDE;
 
+  void AsyncTexImage2DCompleted(scoped_refptr<TransferStateInternal> state);
+  void AsyncTexSubImage2DCompleted(scoped_refptr<TransferStateInternal> state);
+
   static void PerformAsyncTexImage2D(
       TransferStateInternal* state,
       AsyncTexImage2DParams tex_params,
-      AsyncMemoryParams mem_params);
+      base::SharedMemory* shared_memory,
+      uint32 shared_memory_data_offset);
   static void PerformAsyncTexSubImage2D(
       TransferStateInternal* state,
       AsyncTexSubImage2DParams tex_params,
-      AsyncMemoryParams mem_params);
+      base::SharedMemory* shared_memory,
+      uint32 shared_memory_data_offset);
+
+  int texture_upload_count_;
+  base::TimeDelta total_texture_upload_time_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateAndroid);
 };
 
 namespace {
 // Imagination has some odd problems still.
 bool IsImagination() {
   std::string vendor;
   vendor = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
   return vendor.find("Imagination") != std::string::npos;
@@ skipping 17 matching lines @@
         static_cast<AsyncPixelTransferDelegate*>(
             new AsyncPixelTransferDelegateAndroid()));
   } else {
     LOG(INFO) << "Async pixel transfers not supported";
     return make_scoped_ptr(
         static_cast<AsyncPixelTransferDelegate*>(
             new AsyncPixelTransferDelegateStub()));
   }
 }
 
+AsyncPixelTransferDelegateAndroid::AsyncPixelTransferDelegateAndroid()
+    : texture_upload_count_(0) {
+}
+
+AsyncPixelTransferDelegateAndroid::~AsyncPixelTransferDelegateAndroid() {
+}
+
 AsyncPixelTransferState*
     AsyncPixelTransferDelegateAndroid::
         CreateRawPixelTransferState(GLuint texture_id) {
   return static_cast<AsyncPixelTransferState*>(
       new AsyncTransferStateAndroid(texture_id));
 }
 
 namespace {
 // Dummy function to measure completion on
 // the upload thread.
 void NoOp() {}
 } // namespace
 
 void AsyncPixelTransferDelegateAndroid::AsyncNotifyCompletion(
       const base::Closure& task) {
   // Post a no-op task to the upload thread followed
   // by a reply to the callback. The reply will then occur after
   // all async transfers are complete.
   transfer_message_loop_proxy()->PostTaskAndReply(FROM_HERE,
       base::Bind(&NoOp), task);
 }
 
 void AsyncPixelTransferDelegateAndroid::AsyncTexImage2D(
     AsyncPixelTransferState* transfer_state,
     const AsyncTexImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params) {
-  TransferStateInternal* state =
+  scoped_refptr<TransferStateInternal> state =
       static_cast<AsyncTransferStateAndroid*>(transfer_state)->internal_.get();
   DCHECK(mem_params.shared_memory);
+  DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size,
+            mem_params.shm_size);
   DCHECK(state);
   DCHECK(state->texture_id_);
   DCHECK(!state->needs_late_bind_);
   DCHECK(!state->transfer_in_progress_);
   DCHECK_EQ(state->egl_image_, EGL_NO_IMAGE_KHR);
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
   DCHECK_EQ(tex_params.level, 0);
 
   // Mark the transfer in progress and save define params for lazy binding.
   state->transfer_in_progress_ = true;
   state->late_bind_define_params_ = tex_params;
 
   // Duplicate the shared memory so there are no way we can get
   // a use-after-free of the raw pixels.
-  // TODO: Could we pass an own pointer of the new SharedMemory to the task?
-  AsyncMemoryParams duped_mem = mem_params;
-  duped_mem.shared_memory = DuplicateSharedMemory(mem_params.shared_memory,
-                                                  mem_params.shm_size);
   transfer_message_loop_proxy()->PostTaskAndReply(FROM_HERE,
       base::Bind(
           &AsyncPixelTransferDelegateAndroid::PerformAsyncTexImage2D,
-          base::Unretained(state), // This is referenced in reply below.
+          base::Unretained(state.get()),  // This is referenced in reply below.
           tex_params,
-          duped_mem),
+          base::Owned(DuplicateSharedMemory(mem_params.shared_memory,
+                                            mem_params.shm_size)),
+          mem_params.shm_data_offset),
       base::Bind(
-          &TransferStateInternal::TexImage2DCompleted,
+          &AsyncPixelTransferDelegateAndroid::AsyncTexImage2DCompleted,
+          AsWeakPtr(),
           state));
 
   DCHECK(CHECK_GL());
 }
 
 void AsyncPixelTransferDelegateAndroid::AsyncTexSubImage2D(
     AsyncPixelTransferState* transfer_state,
     const AsyncTexSubImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params) {
   TRACE_EVENT2("gpu", "AsyncTexSubImage2D",
                "width", tex_params.width,
                "height", tex_params.height);
-  TransferStateInternal* state =
+  scoped_refptr<TransferStateInternal> state =
       static_cast<AsyncTransferStateAndroid*>(transfer_state)->internal_.get();
   DCHECK(state->texture_id_);
   DCHECK(!state->transfer_in_progress_);
   DCHECK(mem_params.shared_memory);
+  DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size,
+            mem_params.shm_size);
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
   DCHECK_EQ(tex_params.level, 0);
 
   // Mark the transfer in progress.
   state->transfer_in_progress_ = true;
 
   // Create the EGLImage if it hasn't already been created.
   if (!state->egl_image_) {
     TRACE_EVENT0("gpu", "eglCreateImageKHR");
     EGLDisplay egl_display = eglGetCurrentDisplay();
     EGLContext egl_context = eglGetCurrentContext();
     EGLenum egl_target = EGL_GL_TEXTURE_2D_KHR;
     EGLClientBuffer egl_buffer =
         reinterpret_cast<EGLClientBuffer>(state->texture_id_);
     EGLint egl_attrib_list[] = {
         EGL_GL_TEXTURE_LEVEL_KHR, tex_params.level, // mip-level to reference.
         EGL_IMAGE_PRESERVED_KHR, EGL_FALSE,         // throw away texture data.
         EGL_NONE
     };
     state->egl_image_ = eglCreateImageKHR(
         egl_display,
         egl_context,
         egl_target,
         egl_buffer,
         egl_attrib_list);
   }
 
   // Duplicate the shared memory so there are no way we can get
   // a use-after-free of the raw pixels.
-  // TODO: Could we pass an own pointer of the new SharedMemory to the task?
-  AsyncMemoryParams duped_mem = mem_params;
-  duped_mem.shared_memory = DuplicateSharedMemory(mem_params.shared_memory,
-                                                  mem_params.shm_size);
   transfer_message_loop_proxy()->PostTaskAndReply(FROM_HERE,
       base::Bind(
           &AsyncPixelTransferDelegateAndroid::PerformAsyncTexSubImage2D,
-          base::Unretained(state), // This is referenced in reply below.
+          base::Unretained(state.get()),  // This is referenced in reply below.
           tex_params,
-          duped_mem),
+          base::Owned(DuplicateSharedMemory(mem_params.shared_memory,
+                                            mem_params.shm_size)),
+          mem_params.shm_data_offset),
       base::Bind(
-          &TransferStateInternal::TexSubImage2DCompleted,
+          &AsyncPixelTransferDelegateAndroid::AsyncTexSubImage2DCompleted,
+          AsWeakPtr(),
           state));
 
   DCHECK(CHECK_GL());
 }
 
+uint32 AsyncPixelTransferDelegateAndroid::GetTextureUploadCount() {
+  return texture_upload_count_;
+}
+
+base::TimeDelta AsyncPixelTransferDelegateAndroid::GetTotalTextureUploadTime() {
+  return total_texture_upload_time_;
+}
+
+void AsyncPixelTransferDelegateAndroid::AsyncTexImage2DCompleted(
+    scoped_refptr<TransferStateInternal> state) {
+  state->needs_late_bind_ = true;
+  state->transfer_in_progress_ = false;
+}
+
+void AsyncPixelTransferDelegateAndroid::AsyncTexSubImage2DCompleted(
+    scoped_refptr<TransferStateInternal> state) {
+  state->transfer_in_progress_ = false;
+  texture_upload_count_++;
+  total_texture_upload_time_ += state->last_transfer_time_;
+}
+
 namespace {
 void WaitForGl() {
   TRACE_EVENT0("gpu", "eglWaitSync");
 
   // Uploads usually finish on the CPU, but just in case add a fence
   // and guarantee the upload has completed. The flush bit is set to
   // insure we don't wait forever.
   EGLDisplay display = eglGetCurrentDisplay();
   EGLSyncKHR fence = eglCreateSyncKHR(display, EGL_SYNC_FENCE_KHR, NULL);
   EGLint flags = EGL_SYNC_FLUSH_COMMANDS_BIT_KHR;
   EGLTimeKHR time = EGL_FOREVER_KHR;
 
   // This fence is basically like calling glFinish, which is fine if
   // uploads occur on the CPU. If some upload work occurs on the GPU,
   // we may want to delay blocking on the fence.
   eglClientWaitSyncKHR(display, fence, flags, time);
   eglDestroySyncKHR(display, fence);
 }
 } // namespace
 
 void AsyncPixelTransferDelegateAndroid::PerformAsyncTexImage2D(
     TransferStateInternal* state,
     AsyncTexImage2DParams tex_params,
-    AsyncMemoryParams mem_params) {
+    base::SharedMemory* shared_memory,
+    uint32 shared_memory_data_offset) {
   TRACE_EVENT2("gpu", "PerformAsyncTexImage",
                "width", tex_params.width,
                "height", tex_params.height);
   DCHECK(state);
   DCHECK(!state->thread_texture_id_);
   DCHECK_EQ(0, tex_params.level);
   DCHECK_EQ(EGL_NO_IMAGE_KHR, state->egl_image_);
 
-  // TODO(epenner): This is just to insure it is deleted. Could bind() do this?
-  scoped_ptr<SharedMemory> shared_memory =
-      make_scoped_ptr(mem_params.shared_memory);
-
-  void* data = GetAddress(mem_params.shared_memory,
-                          mem_params.shm_size,
-                          mem_params.shm_data_offset,
-                          mem_params.shm_data_size);
+  void* data = GetAddress(shared_memory, shared_memory_data_offset);
   {
     TRACE_EVENT0("gpu", "glTexImage2D no data");
     glGenTextures(1, &state->thread_texture_id_);
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, state->thread_texture_id_);
 
     // These params are needed for EGLImage creation to succeed on several
     // Android devices. I couldn't find this requirement in the EGLImage
     // extension spec, but several devices fail without it.
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
@@ skipping 46 matching lines @@
         data);
   }
 
   WaitForGl();
   DCHECK(CHECK_GL());
 }
 
 void AsyncPixelTransferDelegateAndroid::PerformAsyncTexSubImage2D(
     TransferStateInternal* state,
     AsyncTexSubImage2DParams tex_params,
-    AsyncMemoryParams mem_params) {
+    base::SharedMemory* shared_memory,
+    uint32 shared_memory_data_offset) {
   TRACE_EVENT2("gpu", "PerformAsyncTexSubImage2D",
                "width", tex_params.width,
                "height", tex_params.height);
 
   DCHECK(state);
   DCHECK_NE(EGL_NO_IMAGE_KHR, state->egl_image_);
   DCHECK_EQ(0, tex_params.level);
 
-  // TODO(epenner): This is just to insure it is deleted. Could bind() do this?
-  scoped_ptr<SharedMemory> shared_memory =
-      make_scoped_ptr(mem_params.shared_memory);
+  void* data = GetAddress(shared_memory, shared_memory_data_offset);
 
-  void* data = GetAddress(mem_params.shared_memory,
-                          mem_params.shm_size,
-                          mem_params.shm_data_offset,
-                          mem_params.shm_data_size);
-
+  base::TimeTicks begin_time(base::TimeTicks::HighResNow());
   if (!state->thread_texture_id_) {
     TRACE_EVENT0("gpu", "glEGLImageTargetTexture2DOES");
     glGenTextures(1, &state->thread_texture_id_);
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, state->thread_texture_id_);
     glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, state->egl_image_);
   } else {
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, state->thread_texture_id_);
   }
   {
     TRACE_EVENT0("gpu", "glTexSubImage2D");
     glTexSubImage2D(
         GL_TEXTURE_2D,
         tex_params.level,
         tex_params.xoffset,
         tex_params.yoffset,
         tex_params.width,
         tex_params.height,
         tex_params.format,
         tex_params.type,
         data);
   }
   WaitForGl();
 
   DCHECK(CHECK_GL());
+  state->last_transfer_time_ = base::TimeTicks::HighResNow() - begin_time;
 }
 
 }  // namespace gfx