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;
 
+uint32_t SyncPointClient::GenerateUnprocessedOrderNumber() {
+  DCHECK(sync_point_manager_);
+  const uint32_t order_num = sync_point_manager_->GenerateOrderNumber();
+  base::subtle::Release_Store(&unprocessed_order_num_, order_num);
+  return order_num;
+}
+
+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),
+    unprocessed_order_num_(0) {
+  processing_thread_checker_.DetachFromThread();

[piman, 2015/09/15 23:47:15]

Do you need this? I would think the same thread that creates the SyncPointClient
is also the one that processes the messages and will destroy.

[David Yen, 2015/09/18 18:43:59]

Removed.

+}
+
+void SyncPointClient::Destroy() {
+  sync_point_manager_ = nullptr;
+}
+
+SyncPointClient::~SyncPointClient() {
+  DCHECK(!IsValid());
+}
+
 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() {}
+SyncPointManager::~SyncPointManager() {
+  for (int i = 0; i < NUM_SYNC_POINT_NAMESPACES; ++i) {
+    DCHECK(client_maps_[i].empty());
+  }
+}
+
+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_);
+
+  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;
+}
+
+void SyncPointManager::DestroySyncPointClient(
+    scoped_refptr<SyncPointClient> client) {
+  const SyncPointNamespace namespace_id = client->namespace_id_;
+  const uint32_t client_id = client->client_id_;
+  DCHECK(namespace_id >= 0 && namespace_id < NUM_SYNC_POINT_NAMESPACES);
+  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());
+  it->second->Destroy();

[piman, 2015/09/15 23:47:15]

nit: no need to do this under the lock. you can just call client->Destroy()
before taking the lock.

[David Yen, 2015/09/18 18:43:59]

Done.

+  client_map.erase(it);
+}
+
+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_);
+
+  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 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
@@ skipping 52 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();
 }
 
+uint32_t SyncPointManager::GenerateOrderNumber() {
+  return global_order_num_.GetNext();
+}
+
 }  // namespace gpu