Added a way for sync point clients to issue out of order waits.

gpu/command_buffer/service/sync_point_manager.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_SERVICE_SYNC_POINT_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_SYNC_POINT_MANAGER_H_
 
 #include <stdint.h>
 
 #include <functional>
@@ skipping 24 matching lines @@
 class SyncPointManager;
 
 class GPU_EXPORT SyncPointOrderData
     : public base::RefCountedThreadSafe<SyncPointOrderData> {
  public:
   static scoped_refptr<SyncPointOrderData> Create();
   void Destroy();
 
   uint32_t GenerateUnprocessedOrderNumber(SyncPointManager* sync_point_manager);
   void BeginProcessingOrderNumber(uint32_t order_num);
+  void PauseProcessingOrderNumber(uint32_t order_num);
   void FinishProcessingOrderNumber(uint32_t order_num);
 
   uint32_t processed_order_num() const {
     base::AutoLock auto_lock(lock_);
     return processed_order_num_;
   }
 
   uint32_t unprocessed_order_num() const {
     base::AutoLock auto_lock(lock_);
     return unprocessed_order_num_;
   }
 
   uint32_t current_order_num() const {
     DCHECK(processing_thread_checker_.CalledOnValidThread());
     return current_order_num_;
   }
 
+  bool IsProcessingOrderNumber() {
+    DCHECK(processing_thread_checker_.CalledOnValidThread());
+    return !paused_ && current_order_num_ > processed_order_num();
+  }
+
  private:
   friend class base::RefCountedThreadSafe<SyncPointOrderData>;
   friend class SyncPointClientState;
 
   struct OrderFence {
     uint32_t order_num;
     uint64_t fence_release;
     scoped_refptr<SyncPointClientState> client_state;
 
     OrderFence(uint32_t order,
@@ skipping 18 matching lines @@
       scoped_refptr<SyncPointClientState> client_state,
       uint32_t wait_order_num,
       uint64_t fence_release);
 
   // Non thread-safe functions need to be called from a single thread.
   base::ThreadChecker processing_thread_checker_;
 
   // Current IPC order number being processed (only used on processing thread).
   uint32_t current_order_num_;
 
+  // Whether or not the current order number is being processed or paused.
+  bool paused_;
+
   // This lock protects destroyed_, processed_order_num_,
   // unprocessed_order_num_, and order_fence_queue_. All order numbers (n) in
   // order_fence_queue_ must follow the invariant:
   //   processed_order_num_ < n <= unprocessed_order_num_.
   mutable base::Lock lock_;
 
   bool destroyed_;
 
   // Last finished IPC order number.
   uint32_t processed_order_num_;
@@ skipping 23 matching lines @@
   }
 
   uint64_t fence_sync_release() {
     base::AutoLock auto_lock(fence_sync_lock_);
     return fence_sync_release_;
   }
 
  private:
   friend class base::RefCountedThreadSafe<SyncPointClientState>;
   friend class SyncPointClient;
-  friend class SyncPointClientWaiter;
   friend class SyncPointOrderData;
 
   struct ReleaseCallback {
     uint64_t release_count;
     base::Closure callback_closure;
 
     ReleaseCallback(uint64_t release, const base::Closure& callback);
     ~ReleaseCallback();
 
     bool operator>(const ReleaseCallback& rhs) const {
@@ skipping 52 matching lines @@
   // can supply a task runner.
   bool Wait(SyncPointClientState* release_state,
             uint64_t release_count,
             const base::Closure& wait_complete_callback);
 
   bool WaitNonThreadSafe(SyncPointClientState* release_state,
                          uint64_t release_count,
                          scoped_refptr<base::SingleThreadTaskRunner> runner,
                          const base::Closure& wait_complete_callback);
 
+  // Unordered waits are waits which do not occur within the global order number
+  // processing order (IE. Not between the corresponding
+  // SyncPointOrderData::BeginProcessingOrderNumber() and
+  // SyncPointOrderData::FinishProcessingOrderNumber() calls). Because fence
+  // sync releases must occur within a corresponding order number, these waits
+  // cannot deadlock because they can never depend on any fence sync releases.
+  // This is useful for IPC messages that may be processed out of order with
+  // respect to regular command buffer processing.
+  bool WaitOutOfOrder(SyncPointClientState* release_state,
+                      uint64_t release_count,
+                      const base::Closure& wait_complete_callback);
+
+  bool WaitOutOfOrderNonThreadSafe(
+      SyncPointClientState* release_state,
+      uint64_t release_count,
+      scoped_refptr<base::SingleThreadTaskRunner> runner,
+      const base::Closure& wait_complete_callback);
+
   void ReleaseFenceSync(uint64_t release);
 
  private:
   friend class SyncPointManager;
 
+  SyncPointClient();
   SyncPointClient(SyncPointManager* sync_point_manager,
                   scoped_refptr<SyncPointOrderData> order_data,
                   CommandBufferNamespace namespace_id,
                   uint64_t client_id);
 
   // Sync point manager is guaranteed to exist in the lifetime of the client.
   SyncPointManager* sync_point_manager_;
 
   // Keep the state that is sharable across multiple threads.
   scoped_refptr<SyncPointClientState> client_state_;
 
   // Unique namespace/client id pair for this sync point client.
   const CommandBufferNamespace namespace_id_;
   const uint64_t client_id_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncPointClient);
 };
 
-// A SyncPointClientWaiter is a Sync Point Client which can only wait and on
-// fence syncs and not release any fence syncs itself. Because they cannot
-// release any fence syncs they do not need an associated order number since
-// deadlocks cannot happen. Note that it is important that this class does
-// not exist in the same execution context as a SyncPointClient, or else a
-// deadlock could occur. Basically, SyncPointClientWaiter::Wait() should never
-// be called between SyncPointOrderData::BeginProcessingOrderNumber() and
-// SyncPointOrderData::FinishProcessingOrderNumber() on the same thread.
-class GPU_EXPORT SyncPointClientWaiter {
- public:
-  SyncPointClientWaiter() {}
-  ~SyncPointClientWaiter() {}
-
-  bool Wait(SyncPointClientState* release_state,
-            uint64_t release_count,
-            const base::Closure& wait_complete_callback);
-
-  bool WaitNonThreadSafe(SyncPointClientState* release_state,
-                         uint64_t release_count,
-                         scoped_refptr<base::SingleThreadTaskRunner> runner,
-                         const base::Closure& wait_complete_callback);
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(SyncPointClientWaiter);
-};
-
 // This class manages the sync points, which allow cross-channel
 // synchronization.
 class GPU_EXPORT SyncPointManager {
  public:
   explicit SyncPointManager(bool allow_threaded_wait);
   ~SyncPointManager();
 
   // Creates/Destroy a sync point client which message processors should hold.
   scoped_ptr<SyncPointClient> CreateSyncPointClient(
       scoped_refptr<SyncPointOrderData> order_data,
       CommandBufferNamespace namespace_id,
       uint64_t client_id);
 
+  // Creates a sync point client which cannot process order numbers but can only
+  // Wait out of order.
+  scoped_ptr<SyncPointClient> CreateSyncPointClientWaiter();
+
   // Finds the state of an already created sync point client.
   scoped_refptr<SyncPointClientState> GetSyncPointClientState(
     CommandBufferNamespace namespace_id, uint64_t client_id);
 
   // Generates a sync point, returning its ID. This can me called on any thread.
   // IDs start at a random number. Never return 0.
   uint32_t GenerateSyncPoint();
 
   // Retires a sync point. This will call all the registered callbacks for this
   // sync point. This can only be called on the main thread.
@@ skipping 39 matching lines @@
   SyncPointMap sync_point_map_;
   uint32_t next_sync_point_;
   base::ConditionVariable retire_cond_var_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncPointManager);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_SYNC_POINT_MANAGER_H_