gpu: Add the ability to wait on upload completion.

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"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "ui/gl/async_pixel_transfer_delegate.h"
 #include "ui/gl/async_pixel_transfer_delegate_stub.h"
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/safe_shared_memory_pool.h"
 
 // TODO(epenner): Move thread priorities to base. (crbug.com/170549)
 #include <sys/resource.h>
 
 using base::SharedMemory;
 using base::SharedMemoryHandle;
 
 namespace gfx {
 
 namespace {
 
-// Quick and dirty Atomic flag, that we use for
-// marking completion from the upload thread.
-class AtomicFlag {
- public:
-  AtomicFlag() {
-    base::subtle::Acquire_Store(&value_, 0);
-  }
-  void Set() {
-    base::subtle::Atomic32 old_value = base::subtle::Acquire_CompareAndSwap(
-        &value_, 0, 1);
-    DCHECK_EQ(old_value, 0);
-  }
-  void Unset() {
-    base::subtle::Atomic32 old_value = base::subtle::Release_CompareAndSwap(
-        &value_, 1, 0);
-    DCHECK_EQ(old_value, 1);
-  }
-  bool IsSet() {
-    return base::subtle::Acquire_Load(&value_) == 1;
-  }
- private:
-  base::subtle::Atomic32 value_;
-  DISALLOW_COPY_AND_ASSIGN(AtomicFlag);
-};
-
-
 class TextureUploadStats
     : public base::RefCountedThreadSafe<TextureUploadStats> {
  public:
   TextureUploadStats() : texture_upload_count_(0) {}
 
   void AddUpload(base::TimeDelta transfer_time) {
     base::AutoLock scoped_lock(lock_);
     texture_upload_count_++;
     total_texture_upload_time_ += transfer_time;
   }
@@ skipping 134 matching lines @@
 // else accessed only on the main thread.
 class TransferStateInternal
     : public base::RefCountedThreadSafe<TransferStateInternal> {
  public:
   explicit TransferStateInternal(GLuint texture_id,
                                  bool wait_for_uploads,
                                  bool use_image_preserved)
       : texture_id_(texture_id),
         thread_texture_id_(0),
         needs_late_bind_(false),
+        transfer_completion_(true, true),
         egl_image_(EGL_NO_IMAGE_KHR),
         wait_for_uploads_(wait_for_uploads),
         use_image_preserved_(use_image_preserved) {
     static const AsyncTexImage2DParams zero_params = {0, 0, 0, 0, 0, 0, 0, 0};
     late_bind_define_params_ = zero_params;
   }
 
   // Implement AsyncPixelTransferState:
   bool TransferIsInProgress() {
-    return transfer_in_progress_.IsSet();
+    return !transfer_completion_.IsSignaled();
   }
 
   void BindTransfer(AsyncTexImage2DParams* bound_params) {
     TRACE_EVENT2("gpu", "BindAsyncTransfer glEGLImageTargetTexture2DOES",
                  "width", late_bind_define_params_.width,
                  "height", late_bind_define_params_.height);
     DCHECK(bound_params);
     DCHECK(texture_id_);
     *bound_params = late_bind_define_params_;
     if (!needs_late_bind_)
@@ skipping 51 matching lines @@
     // GPU action that needs to occur. We could use fences and try
     // to do this less often. However, on older drivers fences are
     // not always reliable (eg. Mali-400 just blocks forever).
     if (wait_for_uploads_) {
       TRACE_EVENT0("gpu", "glFinish");
       glFinish();
     }
   }
 
   void MarkAsTransferIsInProgress() {
-    transfer_in_progress_.Set();
+    transfer_completion_.Reset();
   }
 
   void MarkAsCompleted() {
-    transfer_in_progress_.Unset();
+    transfer_completion_.Signal();
+  }
+
+  void WaitForTransferCompletion() {
+    transfer_completion_.Wait();
   }
 
  protected:
   friend class base::RefCountedThreadSafe<TransferStateInternal>;
   friend class AsyncPixelTransferDelegateAndroid;
 
   static void DeleteTexture(GLuint id) {
     glDeleteTextures(1, &id);
   }
 
@@ skipping 15 matching lines @@
   GLuint thread_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.
-  AtomicFlag transfer_in_progress_;
+  base::WaitableEvent transfer_completion_;
 
   // 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_;
 
   // Customize when we block on fences (these are work-arounds).
   bool wait_for_uploads_;
   bool use_image_preserved_;
 };
 
 // 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,
                                      bool wait_for_uploads,
                                      bool use_image_preserved)
       : internal_(new TransferStateInternal(texture_id,
                                             wait_for_uploads,
                                             use_image_preserved)) {
   }
   virtual ~AsyncTransferStateAndroid() {}
-  virtual bool TransferIsInProgress() {
+  virtual bool TransferIsInProgress() OVERRIDE {
       return internal_->TransferIsInProgress();
   }
-  virtual void BindTransfer(AsyncTexImage2DParams* bound_params) {
+  virtual void BindTransfer(AsyncTexImage2DParams* bound_params) OVERRIDE {
       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 base::SupportsWeakPtr<AsyncPixelTransferDelegateAndroid> {
  public:
   AsyncPixelTransferDelegateAndroid();
   virtual ~AsyncPixelTransferDelegateAndroid();
 
   // implement AsyncPixelTransferDelegate:
   virtual void AsyncNotifyCompletion(
       const AsyncMemoryParams& mem_params,
       const CompletionCallback& callback) 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 void WaitForTransferCompletion(
+      AsyncPixelTransferState* state) OVERRIDE;
   virtual uint32 GetTextureUploadCount() OVERRIDE;
   virtual base::TimeDelta GetTotalTextureUploadTime() OVERRIDE;
 
  private:
   // implement AsyncPixelTransferDelegate:
   virtual AsyncPixelTransferState*
       CreateRawPixelTransferState(GLuint texture_id) OVERRIDE;
 
   static void PerformNotifyCompletion(
       AsyncMemoryParams mem_params,
@@ skipping 96 matching lines @@
       FROM_HERE,
       base::Bind(&AsyncPixelTransferDelegateAndroid::PerformNotifyCompletion,
                  mem_params,
                  base::Owned(
                      new ScopedSafeSharedMemory(safe_shared_memory_pool(),
                                                 mem_params.shared_memory,
                                                 mem_params.shm_size)),
                  callback));
 }
 
+void AsyncPixelTransferDelegateAndroid::WaitForTransferCompletion(
+      AsyncPixelTransferState* transfer_state) {
+  TRACE_EVENT0("gpu", "WaitForTransferCompletion");
+  scoped_refptr<TransferStateInternal> state =
+      static_cast<AsyncTransferStateAndroid*>(transfer_state)->internal_.get();
+  DCHECK(state);
+  DCHECK(state->texture_id_);
+
+  if (state->TransferIsInProgress()) {
+    // TODO(epenner): Move thread priorities to base. (crbug.com/170549)
+    int default_nice_value = 0;  // Default priority.
+    int idle_nice_value    = 10; // Idle priority.
+    setpriority(PRIO_PROCESS,
+                g_transfer_thread.Pointer()->thread_id(),
+                default_nice_value);
+
+    state->WaitForTransferCompletion();
+    DCHECK(!state->TransferIsInProgress());
+
+    // TODO(epenner): Move thread priorities to base. (crbug.com/170549)
+    setpriority(PRIO_PROCESS,
+                g_transfer_thread.Pointer()->thread_id(),
+                idle_nice_value);
+  }
+}
+
 void AsyncPixelTransferDelegateAndroid::AsyncTexImage2D(
     AsyncPixelTransferState* transfer_state,
     const AsyncTexImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params) {
   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);
@@ skipping 309 matching lines @@
   if (texture_upload_stats_) {
     texture_upload_stats_->AddUpload(
         base::TimeTicks::HighResNow() - begin_time);
   }
 
   DCHECK(CHECK_GL());
   return true;
 }
 
 }  // namespace gfx