Invalid sync token waits now automatically get released.

gpu/command_buffer/service/sync_point_manager.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 "gpu/command_buffer/service/sync_point_manager.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 70 matching lines @@
       if (order_fence_queue_.top().order_num < order_num) {
         ensure_releases.push_back(order_fence);
         order_fence_queue_.pop();
         continue;
       }
       break;
     }
   }
 
   for (OrderFence& order_fence : ensure_releases) {
-    order_fence.client_state->EnsureReleased(order_fence.fence_release);
+    order_fence.client_state->EnsureWaitReleased(order_fence.fence_release,
+                                                 order_fence.release_callback);
   }
 }
 
 void SyncPointOrderData::PauseProcessingOrderNumber(uint32_t order_num) {
   DCHECK(processing_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(current_order_num_, order_num);
   DCHECK(!paused_);
   paused_ = true;
 }
 
@@ skipping 17 matching lines @@
       if (order_fence_queue_.top().order_num <= order_num) {
         ensure_releases.push_back(order_fence);
         order_fence_queue_.pop();
         continue;
       }
       break;
     }
   }
 
   for (OrderFence& order_fence : ensure_releases) {
-    order_fence.client_state->EnsureReleased(order_fence.fence_release);
+    order_fence.client_state->EnsureWaitReleased(order_fence.fence_release,
+                                                 order_fence.release_callback);
   }
 }
 
 SyncPointOrderData::OrderFence::OrderFence(
     uint32_t order,
     uint64_t release,
+    const base::Closure& callback,
     scoped_refptr<SyncPointClientState> state)
-    : order_num(order), fence_release(release), client_state(state) {}
+    : order_num(order),
+      fence_release(release),
+      release_callback(callback),
+      client_state(state) {}
 
 SyncPointOrderData::OrderFence::OrderFence(const OrderFence& other) = default;
 
 SyncPointOrderData::OrderFence::~OrderFence() {}
 
 SyncPointOrderData::SyncPointOrderData()
     : current_order_num_(0),
       paused_(false),
       destroyed_(false),
       processed_order_num_(0),
       unprocessed_order_num_(0) {}
 
 SyncPointOrderData::~SyncPointOrderData() {}
 
 bool SyncPointOrderData::ValidateReleaseOrderNumber(
     scoped_refptr<SyncPointClientState> client_state,
     uint32_t wait_order_num,
-    uint64_t fence_release) {
+    uint64_t fence_release,
+    const base::Closure& release_callback) {
   base::AutoLock auto_lock(lock_);
   if (destroyed_)
     return false;
 
   // Release should have a possible unprocessed order number lower
   // than the wait order number.
   if ((processed_order_num_ + 1) >= wait_order_num)
     return false;
 
   // Release should have more unprocessed numbers if we are waiting.
   if (unprocessed_order_num_ <= processed_order_num_)
     return false;
 
   // So far it could be valid, but add an order fence guard to be sure it
   // gets released eventually.
   const uint32_t expected_order_num =
       std::min(unprocessed_order_num_, wait_order_num);
-  order_fence_queue_.push(
-      OrderFence(expected_order_num, fence_release, client_state));
+  order_fence_queue_.push(OrderFence(expected_order_num, fence_release,
+                                     release_callback, client_state));
   return true;
 }
 
 SyncPointClientState::ReleaseCallback::ReleaseCallback(
     uint64_t release,
     const base::Closure& callback)
     : release_count(release), callback_closure(callback) {}
 
 SyncPointClientState::ReleaseCallback::ReleaseCallback(
     const ReleaseCallback& other) = default;
@@ skipping 11 matching lines @@
                                           CommandBufferId client_id,
                                           uint32_t wait_order_num,
                                           uint64_t release,
                                           const base::Closure& callback) {
   // Lock must be held the whole time while we validate otherwise it could be
   // released while we are checking.
   {
     base::AutoLock auto_lock(fence_sync_lock_);
     if (release > fence_sync_release_) {
       if (!order_data_->ValidateReleaseOrderNumber(this, wait_order_num,
-                                                   release)) {
+                                                   release, callback)) {
         return false;
       } else {
         // Add the callback which will be called upon release.
         release_callback_queue_.push(ReleaseCallback(release, callback));
         if (!on_wait_callback_.is_null())
           on_wait_callback_.Run(namespace_id, client_id);
         return true;
       }
     }
   }
 
   // Already released, run the callback now.
   callback.Run();
   return true;
 }
 
 void SyncPointClientState::ReleaseFenceSync(uint64_t release) {
   // Call callbacks without the lock to avoid possible deadlocks.
   std::vector<base::Closure> callback_list;
   {
     base::AutoLock auto_lock(fence_sync_lock_);
-    ReleaseFenceSyncLocked(release, &callback_list);
+    DCHECK_GT(release, fence_sync_release_);
+
+    fence_sync_release_ = release;
+    while (!release_callback_queue_.empty() &&
+           release_callback_queue_.top().release_count <= release) {
+      callback_list.push_back(release_callback_queue_.top().callback_closure);
+      release_callback_queue_.pop();
+    }
   }
 
   for (const base::Closure& closure : callback_list) {
     closure.Run();
   }
 }
 
-void SyncPointClientState::EnsureReleased(uint64_t release) {
+void SyncPointClientState::EnsureWaitReleased(uint64_t release,
+                                              const base::Closure& callback) {
   // Call callbacks without the lock to avoid possible deadlocks.
-  std::vector<base::Closure> callback_list;
+  bool call_callback = false;
   {
     base::AutoLock auto_lock(fence_sync_lock_);
     if (release <= fence_sync_release_)
       return;
 
-    ReleaseFenceSyncLocked(release, &callback_list);
+    std::vector<ReleaseCallback> popped_callbacks;
+    popped_callbacks.reserve(release_callback_queue_.size());
+
+    while (!release_callback_queue_.empty() &&
+           release_callback_queue_.top().release_count <= release) {
+      const ReleaseCallback& top_item = release_callback_queue_.top();
+      if (top_item.release_count == release &&
+          top_item.callback_closure.Equals(callback)) {
+        // Call the callback, and discard this item from the callback queue.
+        call_callback = true;
+      } else {
+        // Store the item to be placed back into the callback queue later.
+        popped_callbacks.push_back(top_item);
+      }
+      release_callback_queue_.pop();
+    }
+
+    // Add back in popped items.
+    for (const ReleaseCallback& popped_callback : popped_callbacks) {
+      release_callback_queue_.push(popped_callback);
+    }
   }
 
-  for (const base::Closure& closure : callback_list) {
-    closure.Run();
+  if (call_callback) {
+    // This effectively releases the wait without releasing the fence.
+    callback.Run();
   }
 }
 
-void SyncPointClientState::ReleaseFenceSyncLocked(
-    uint64_t release,
-    std::vector<base::Closure>* callback_list) {
-  fence_sync_lock_.AssertAcquired();
-  DCHECK_GT(release, fence_sync_release_);
-
-  fence_sync_release_ = release;
-  while (!release_callback_queue_.empty() &&
-         release_callback_queue_.top().release_count <= release) {
-    callback_list->push_back(release_callback_queue_.top().callback_closure);
-    release_callback_queue_.pop();
-  }
-}
-
 void SyncPointClientState::SetOnWaitCallback(const OnWaitCallback& callback) {
   on_wait_callback_ = callback;
 }
 
 SyncPointClient::~SyncPointClient() {
   if (namespace_id_ != gpu::CommandBufferNamespace::INVALID) {
     // Release all fences on destruction.
     client_state_->ReleaseFenceSync(UINT64_MAX);
 
     sync_point_manager_->DestroySyncPointClient(namespace_id_, client_id_);
@@ skipping 143 matching lines @@
   DCHECK_LT(static_cast<size_t>(namespace_id), arraysize(client_maps_));
 
   base::AutoLock auto_lock(client_maps_lock_);
   ClientMap& client_map = client_maps_[namespace_id];
   ClientMap::iterator it = client_map.find(client_id);
   DCHECK(it != client_map.end());
   client_map.erase(it);
 }
 
 }  // namespace gpu