Implemented new fence syncs which replaces the old sync points.

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 <climits>
 
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/sequence_checker.h"
 
 namespace gpu {
 
 static const int kMaxSyncBase = INT_MAX;
 
 scoped_refptr<SyncPointClientState> SyncPointClientState::Create() {
   return new SyncPointClientState;
 }
 
 uint32_t SyncPointClientState::GenerateUnprocessedOrderNumber(
     SyncPointManager* sync_point_manager) {
   const uint32_t order_num = sync_point_manager->GenerateOrderNumber();
   base::subtle::Release_Store(&unprocessed_order_num_, order_num);
   return order_num;
 }
 
+void SyncPointClientState::BeginProcessingOrderNumber(uint32_t order_num) {
+  DCHECK(processing_thread_checker_.CalledOnValidThread());
+  DCHECK_GE(order_num, current_order_num_);
+  current_order_num_ = order_num;
+}
+
+void SyncPointClientState::FinishProcessingOrderNumber(uint32_t order_num) {
+  DCHECK(processing_thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(current_order_num_, order_num);
+  DCHECK_GT(order_num, processed_order_num());
+
+  // Catch invalid waits which were waiting on fence syncs that do not exist.
+  uint32_t invalid_release = 0;
+  {
+    base::AutoLock auto_lock(fence_sync_lock_);
+    uint32_t highest_wait_release = 0;
+    while (!order_fence_queue_.empty() &&
+           order_fence_queue_.top().order_num <= order_num) {
+      const uint32_t fence_release = order_fence_queue_.top().fence_release;
+      highest_wait_release = std::max(highest_wait_release, fence_release);
+      order_fence_queue_.pop();
+    }
+
+    if (highest_wait_release > fence_sync_release_) {
+      invalid_release = fence_sync_release_;
+    }
+  }
+
+  if (invalid_release) {
+    // Bad wait for release that doesn't exist, release all waits up to here.
+    ReleaseFenceSync(invalid_release);
+  }
+
+  base::subtle::Release_Store(&processed_order_num_, order_num);
+}
+
 SyncPointClientState::SyncPointClientState()
   : processed_order_num_(0),
     unprocessed_order_num_(0),
-    current_order_num_(0) {
+    current_order_num_(0),
+    fence_sync_release_(0) {
 }
 
 SyncPointClientState::~SyncPointClientState() {
+  // Release all fences on destruction.
+  ReleaseFenceSync(UINT32_MAX);
+}
+
+SyncPointClientState::ReleaseCallback::ReleaseCallback(
+    uint32_t release, const base::Closure& callback)
+  : release_count(release),
+    callback_closure(callback) {
+}
+
+SyncPointClientState::ReleaseCallback::~ReleaseCallback() {
+}
+
+bool SyncPointClientState::WaitForRelease(uint32_t wait_order_num,
+                                          uint32_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_) {
+      const uint32_t processed_num = processed_order_num();
+      const uint32_t unprocessed_num = unprocessed_order_num();
+
+      // Release should have a lower order number than wait order number.
+      if (processed_num > wait_order_num)
+        return false;
+
+      // Release should have more unprocessed numbers if we are waiting.
+      if (unprocessed_num > processed_num)
+        return false;
+
+      // Add the callback which will be called upon release.
+      release_callback_queue_.push(ReleaseCallback(release, callback));
+
+      // Validate by ensuring fence is released by the expected order number.
+      const uint32_t expected_order_num = std::min(unprocessed_num,
+                                                   wait_order_num);
+      order_fence_queue_.push(OrderFence(expected_order_num, release));
+
+      return true;
+    }
+  }
+
+  // Already released, run the callback now.
+  callback.Run();
+  return true;
+}
+
+void SyncPointClientState::ReleaseFenceSync(uint32_t release) {
+  // Call callbacks without the lock to avoid possible deadlocks.
+  std::vector<base::Closure> callback_list;
+  {
+    base::AutoLock auto_lock(fence_sync_lock_);
+    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();
+  }
 }
 
 SyncPointClient::~SyncPointClient() {
   sync_point_manager_->DestroySyncPointClient(namespace_id_, client_id_);
 }
 
+bool SyncPointClient::Wait(scoped_refptr<SyncPointClientState> release_state,
+                           uint32_t release_count,
+                           const base::Closure& wait_complete_callback) {
+  const uint32_t wait_order_number = client_state_->current_order_num();
+  return release_state->WaitForRelease(wait_order_number,
+                                       release_count,
+                                       wait_complete_callback);
+}
+
+void SyncPointClient::ReleaseFenceSync(uint32_t release) {
+  client_state_->ReleaseFenceSync(release);
+}
+
 SyncPointClient::SyncPointClient(SyncPointManager* sync_point_manager,
                                  scoped_refptr<SyncPointClientState> state,
                                  CommandBufferNamespace namespace_id,
                                  uint64_t client_id)
   : sync_point_manager_(sync_point_manager),
     client_state_(state),
     namespace_id_(namespace_id),
     client_id_(client_id) {
 }
 
@@ skipping 126 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