Added global order numbers to in process command buffers.

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;
 
+SyncPointClient::SyncPointClient(SyncPointManager* sync_point_manager,
+                                 SyncPointNamespace namespace_id,
+                                 uint64_t client_id)
+  : sync_point_manager_(sync_point_manager),
+    namespace_id_(namespace_id),
+    client_id_(client_id),
+    current_order_num_(0),
+    processed_order_num_(0) {
+}
+
+SyncPointClient::~SyncPointClient() {
+  sync_point_manager_->RemoveSyncPointClient(namespace_id_, client_id_);
+}
+
 SyncPointManager::SyncPointManager(bool allow_threaded_wait)
     : allow_threaded_wait_(allow_threaded_wait),
       // To reduce the risk that a sync point created in a previous GPU process
       // will be in flight in the next GPU process, randomize the starting sync
       // point number. http://crbug.com/373452
       next_sync_point_(base::RandInt(1, kMaxSyncBase)),
-      retire_cond_var_(&lock_) {}
+      retire_cond_var_(&lock_) {
+  global_order_num_.GetNext();
+}
 
 SyncPointManager::~SyncPointManager() {}

[piman, 2015/09/14 23:43:53]

Can you DCHECK that all client maps are empty? Otherwise it indicates that there
is still a live SyncPointClient that has a (now stale) reference to this.

[David Yen, 2015/09/15 18:09:31]

I was going to do this, must have forgotten. Done now.

 
+scoped_refptr<SyncPointClient> SyncPointManager::CreateSyncPointClient(
+    SyncPointNamespace namespace_id, uint64_t client_id) {
+  DCHECK(namespace_id >= 0 && namespace_id < NUM_SYNC_POINT_NAMESPACES);
+  base::AutoLock auto_lock(client_maps_lock_[namespace_id]);
+
+  ClientMap& client_map = client_maps_[namespace_id];
+  std::pair<ClientMap::iterator, bool> result = client_map.insert(
+      std::make_pair(client_id, new SyncPointClient(this,
+                                                    namespace_id,
+                                                    client_id)));
+  DCHECK(result.second);
+
+  return result.first->second;
+}
+
+scoped_refptr<SyncPointClient> SyncPointManager::GetSyncPointClient(
+    SyncPointNamespace namespace_id, uint64_t client_id) {
+  DCHECK(namespace_id >= 0 && namespace_id < NUM_SYNC_POINT_NAMESPACES);
+  base::AutoLock auto_lock(client_maps_lock_[namespace_id]);
+
+  ClientMap& client_map = client_maps_[namespace_id];
+  ClientMap::iterator it = client_map.find(client_id);
+  if (it != client_map.end()) {
+    return it->second;
+  }
+  return nullptr;
+}
+
+uint32_t SyncPointManager::GenerateOrderNumber() {
+  return global_order_num_.GetNext();
+}
+
 uint32 SyncPointManager::GenerateSyncPoint() {
   base::AutoLock lock(lock_);
   uint32 sync_point = next_sync_point_++;
   // When an integer overflow occurs, don't return 0.
   if (!sync_point)
     sync_point = next_sync_point_++;
 
   // Note: wrapping would take days for a buggy/compromized renderer that would
   // insert sync points in a loop, but if that were to happen, better explicitly
   // crash the GPU process than risk worse.
@@ skipping 51 matching lines @@
   while (!IsSyncPointRetiredLocked(sync_point)) {
     retire_cond_var_.Wait();
   }
 }
 
 bool SyncPointManager::IsSyncPointRetiredLocked(uint32 sync_point) {
   lock_.AssertAcquired();
   return sync_point_map_.find(sync_point) == sync_point_map_.end();
 }
 
+void SyncPointManager::RemoveSyncPointClient(SyncPointNamespace namespace_id,
+                                             uint64_t client_id) {
+  DCHECK(namespace_id >= 0 && namespace_id < NUM_SYNC_POINT_NAMESPACES);
+  base::AutoLock auto_lock(client_maps_lock_[namespace_id]);
+  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