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 <sys/resource.h>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 136 matching lines @@
   }
 
   void BindTransfer(AsyncTexImage2DParams* bound_params) {
     DCHECK(bound_params);
     DCHECK(needs_late_bind_);
     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;
 
   virtual ~TransferStateInternal() {
     if (egl_image_) {
       EGLDisplay display = eglGetCurrentDisplay();
       eglDestroyImageKHR(display, egl_image_);
     }
   }
 
   // The 'real' texture.
   GLuint texture_id_;
 
   // Indicates there is a new EGLImage and the 'real'
   // texture needs to be bound to it as an EGLImage target.
   bool needs_late_bind_;
 
   // 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 {
  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;
 
   base::MessageLoopProxy* transfer_message_loop_proxy() {
     return g_transfer_thread.Pointer()->message_loop_proxy();
   }
+
+  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,

[epenner, 2012/12/22 03:22:42]

Is there no way to keep this as one parameter?  Not sure it's worth the other
cleanup..

[epenner, 2012/12/22 20:48:17]

Hmm, could we just pass a "Safe" shared memory parameter in addition to the old
struct?  Then it will be easy to test the unsafe version (I still want to test
that it has no performance impact)

[reveman, 2012/12/22 21:56:24]

I guess we could do that. I removed shared_memory_size and
shared_memory_data_size parameters from the latest patch as it seemed
unnecessary to pass those to the other thread. I'll switch to a "safe" shm mem
parameter if you prefer that.

+      uint32 shared_memory_size,
+      uint32 shared_memory_data_offset,
+      uint32 shared_memory_data_size);
   static void PerformAsyncTexSubImage2D(
       TransferStateInternal* state,
       AsyncTexSubImage2DParams tex_params,
-      AsyncMemoryParams mem_params);
+      base::SharedMemory* shared_memory,
+      uint32 shared_memory_size,
+      uint32 shared_memory_data_offset,
+      uint32 shared_memory_data_size);
+
+  int texture_upload_count_;
+  base::TimeDelta total_texture_upload_time_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateAndroid);
 };
 
 // We only used threaded uploads when we can:
 // - Create EGLImages out of OpenGL textures (EGL_KHR_gl_texture_2D_image)
 // - Bind EGLImages to OpenGL textures (GL_OES_EGL_image)
 // - Use fences (to test for upload completion).
 scoped_ptr<AsyncPixelTransferDelegate>
     AsyncPixelTransferDelegate::Create(gfx::GLContext* context) {
@@ skipping 11 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(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_size,
+          mem_params.shm_data_offset,
+          mem_params.shm_data_size),
       base::Bind(
-          &TransferStateInternal::TexImage2DCompleted,
+          &AsyncPixelTransferDelegateAndroid::AsyncTexImage2DCompleted,
+          base::Unretained(this),

[epenner, 2012/12/22 03:22:42]

I don't think it's safe to pass this pointer as is. Uploads can out-live the
transfer-delegate.  The state is kept alive.

Hmm, it looks like the delegate either needs to support weak pointer, or the
uploads stats could be stored in the thread object.

[reveman, 2012/12/22 21:56:24]

added support for weak pointer in latest patch. it would be nice to make the
transfer thread part of the transfer delegate so it will be shut down and all
pending tasks are completed when destroying the delegate. Looks like
TransferStateInternal::thread_texture_id would have to be registered with the
transfer thread so it could be deleted at thread cleanup.

           state));
 }
 
 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_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;
 
@@ skipping 12 matching lines @@
     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_size,
+          mem_params.shm_data_offset,
+          mem_params.shm_data_size),
       base::Bind(
-          &TransferStateInternal::TexSubImage2DCompleted,
+          &AsyncPixelTransferDelegateAndroid::AsyncTexSubImage2DCompleted,
+          base::Unretained(this),
           state));
 }
 
+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 WaitForGlFence() {
   // 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) {
-  // 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);
+    base::SharedMemory* shared_memory,
+    uint32 shared_memory_size,
+    uint32 shared_memory_data_offset,
+    uint32 shared_memory_data_size) {
+  void* data = GetAddress(shared_memory,
+                          shared_memory_size,
+                          shared_memory_data_offset,
+                          shared_memory_data_size);
 
   // In texImage2D, we do everything on the upload thread. This is
   // because texImage2D can incur CPU allocation cost, and it also
   // 'orphans' any previous EGLImage bound to the texture.
   DCHECK_EQ(0, tex_params.level);
   DCHECK_EQ(EGL_NO_IMAGE_KHR, state->egl_image_);
   TRACE_EVENT2("gpu", "performAsyncTexImage2D",
                "width", tex_params.width,
                "height", tex_params.height);
 
@@ skipping 35 matching lines @@
   WaitForGlFence();
 
   // We can delete this thread's texture as the real texture
   // now contains the data.
   glDeleteTextures(1, &temp_texture);
 }
 
 void AsyncPixelTransferDelegateAndroid::PerformAsyncTexSubImage2D(
     TransferStateInternal* state,
     AsyncTexSubImage2DParams tex_params,
-    AsyncMemoryParams mem_params) {
-  // 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);
+    base::SharedMemory* shared_memory,
+    uint32 shared_memory_size,
+    uint32 shared_memory_data_offset,
+    uint32 shared_memory_data_size) {
+  void* data = GetAddress(shared_memory,
+                          shared_memory_size,
+                          shared_memory_data_offset,
+                          shared_memory_data_size);
 
   // For a texSubImage, the texture must already have been
   // created on the main thread, along with EGLImageKHR.
   DCHECK_NE(EGL_NO_IMAGE_KHR, state->egl_image_);
   DCHECK_EQ(0, tex_params.level);
   TRACE_EVENT2("gpu", "performAsyncTexSubImage2D",
                "width", tex_params.width,
                "height", tex_params.height);
 
+  base::TimeTicks begin_time(base::TimeTicks::HighResNow());
   // Create a texture from the image and upload to it.
   GLuint temp_texture = 0;
   glGenTextures(1, &temp_texture);
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_2D, temp_texture);
   glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, state->egl_image_);
   {
     TRACE_EVENT0("gpu", "performAsyncTexSubImage2D 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);
   }
   WaitForGlFence();
 
   // We can delete this thread's texture as the real texture
   // now contains the data.
   glDeleteTextures(1, &temp_texture);
+  state->last_transfer_time_ = base::TimeTicks::HighResNow() - begin_time;
 }
 
 }  // namespace gfx