Implemented new fence syncs which replaces the old sync points.

gpu/command_buffer/service/sync_point_manager_unittest.cc

Index: gpu/command_buffer/service/sync_point_manager_unittest.cc
diff --git a/gpu/command_buffer/service/sync_point_manager_unittest.cc b/gpu/command_buffer/service/sync_point_manager_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8896eff409410273059b8f7c05e38aaed7fee1c7
--- /dev/null
+++ b/gpu/command_buffer/service/sync_point_manager_unittest.cc
@@ -0,0 +1,309 @@
+// Copyright (c) 2015 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 "base/bind.h"
+#include "gpu/command_buffer/service/sync_point_manager.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gpu {
+
+class SyncPointManagerTest : public testing::Test {
+ public:
+  SyncPointManagerTest() {
+  }
+
+  ~SyncPointManagerTest() override {}
+
+ protected:
+  void SetUp() override {
+    sync_point_manager_.reset(new SyncPointManager(false));
+  }
+
+  void TearDown() override {
+    sync_point_manager_.reset();
+  }
+
+  // Simple static function which can be used to test callbacks.
+  static void SetIntegerFunction(int* test, int value) {
+    *test = value;
+  }
+
+  scoped_ptr<SyncPointManager> sync_point_manager_;
+};
+
+struct SyncPointStream {
+  scoped_refptr<SyncPointOrderData> order_data;
+  scoped_ptr<SyncPointClient> client;
+  uint32_t current_order_num;
+
+  SyncPointStream(SyncPointManager* sync_point_manager,
+                  CommandBufferNamespace namespace_id,
+                  uint64_t command_buffer_id)
+    : order_data(SyncPointOrderData::Create()),
+      client(sync_point_manager->CreateSyncPointClient(order_data,
+                                                       namespace_id,
+                                                       command_buffer_id)),
+      current_order_num(0) {
+  }
+
+  ~SyncPointStream() {
+    order_data->Destroy();
+    order_data = nullptr;
+  }
+
+  void AllocateOrderNum(SyncPointManager* sync_point_manager) {
+    ASSERT_EQ(0u, current_order_num);
+    current_order_num =
+        order_data->GenerateUnprocessedOrderNumber(sync_point_manager);
+  }
+
+  void BeginProcessing() {
+    ASSERT_NE(0u, current_order_num);
+    order_data->BeginProcessingOrderNumber(current_order_num);
+  }
+
+  void EndProcessing() {
+    ASSERT_NE(0u, current_order_num);
+    order_data->FinishProcessingOrderNumber(current_order_num);
+    current_order_num = 0;
+  }
+};
+
+TEST_F(SyncPointManagerTest, BasicSyncPointOrderDataTest) {
+  scoped_refptr<SyncPointOrderData> order_data = SyncPointOrderData::Create();
+
+  EXPECT_EQ(0u, order_data->current_order_num());
+  EXPECT_EQ(0u, order_data->processed_order_num());
+  EXPECT_EQ(0u, order_data->unprocessed_order_num());
+
+  const uint32_t order_num =
+      order_data->GenerateUnprocessedOrderNumber(sync_point_manager_.get());
+  EXPECT_EQ(1u, order_num);
+
+  EXPECT_EQ(0u, order_data->current_order_num());
+  EXPECT_EQ(0u, order_data->processed_order_num());
+  EXPECT_EQ(order_num, order_data->unprocessed_order_num());
+
+  order_data->BeginProcessingOrderNumber(order_num);
+  EXPECT_EQ(order_num, order_data->current_order_num());
+  EXPECT_EQ(0u, order_data->processed_order_num());
+  EXPECT_EQ(order_num, order_data->unprocessed_order_num());
+
+  order_data->FinishProcessingOrderNumber(order_num);
+  EXPECT_EQ(order_num, order_data->current_order_num());
+  EXPECT_EQ(order_num, order_data->processed_order_num());
+  EXPECT_EQ(order_num, order_data->unprocessed_order_num());
+}
+
+TEST_F(SyncPointManagerTest, SyncPointClientRegistration) {
+  const CommandBufferNamespace kNamespaceId =
+      gpu::CommandBufferNamespace::GPU_IO;
+  const uint64_t kBufferId = 0x123;
+
+  scoped_refptr<SyncPointClientState> empty_state =
+      sync_point_manager_->GetSyncPointClientState(kNamespaceId, kBufferId);
+  EXPECT_FALSE(empty_state);
+
+  scoped_refptr<SyncPointOrderData> order_data = SyncPointOrderData::Create();
+
+  scoped_ptr<SyncPointClient> client =
+      sync_point_manager_->CreateSyncPointClient(order_data,
+                                                 kNamespaceId,
+                                                 kBufferId);
+
+  EXPECT_EQ(order_data, client->client_state()->order_data());
+  EXPECT_EQ(client->client_state(),
+            sync_point_manager_->GetSyncPointClientState(kNamespaceId,
+                                                         kBufferId));
+}
+
+TEST_F(SyncPointManagerTest, BasicFenceSyncRelease) {
+  const CommandBufferNamespace kNamespaceId =
+      gpu::CommandBufferNamespace::GPU_IO;
+  const uint64_t kBufferId = 0x123;
+
+  scoped_refptr<SyncPointOrderData> order_data = SyncPointOrderData::Create();
+  scoped_ptr<SyncPointClient> client =
+      sync_point_manager_->CreateSyncPointClient(order_data,
+                                                 kNamespaceId,
+                                                 kBufferId);
+  scoped_refptr<SyncPointClientState> client_state = client->client_state();
+
+  EXPECT_EQ(0u, client_state->fence_sync_release());
+  EXPECT_FALSE(client_state->IsFenceSyncReleased(1));
+
+  client->ReleaseFenceSync(1);
+
+  EXPECT_EQ(1u, client_state->fence_sync_release());
+  EXPECT_TRUE(client_state->IsFenceSyncReleased(1));
+}
+
+TEST_F(SyncPointManagerTest, BasicFenceSyncWaitRelease) {
+  const CommandBufferNamespace kNamespaceId =
+      gpu::CommandBufferNamespace::GPU_IO;
+  const uint64_t kBufferId1 = 0x123;
+  const uint64_t kBufferId2 = 0x234;
+
+  SyncPointStream release_stream(sync_point_manager_.get(),
+                                 kNamespaceId,
+                                 kBufferId1);
+  SyncPointStream wait_stream(sync_point_manager_.get(),
+                              kNamespaceId,
+                              kBufferId2);
+
+  release_stream.AllocateOrderNum(sync_point_manager_.get());
+  wait_stream.AllocateOrderNum(sync_point_manager_.get());
+
+  wait_stream.BeginProcessing();
+  int test_num = 10;
+  const bool valid_wait =
+      wait_stream.client->Wait(
+          release_stream.client->client_state(),
+          1,
+          base::Bind(&SyncPointManagerTest::SetIntegerFunction,
+                     &test_num,
+                     123));
+  ASSERT_TRUE(valid_wait);
+  EXPECT_EQ(10, test_num);
+
+  release_stream.BeginProcessing();
+  release_stream.client->ReleaseFenceSync(1);
+  EXPECT_EQ(123, test_num);
+}
+
+TEST_F(SyncPointManagerTest, OutOfOrderRelease) {
+  const CommandBufferNamespace kNamespaceId =
+      gpu::CommandBufferNamespace::GPU_IO;
+  const uint64_t kBufferId1 = 0x123;
+  const uint64_t kBufferId2 = 0x234;
+
+  SyncPointStream release_stream(sync_point_manager_.get(),
+                                 kNamespaceId,
+                                 kBufferId1);
+  SyncPointStream wait_stream(sync_point_manager_.get(),
+                              kNamespaceId,
+                              kBufferId2);
+
+  // Generate wait order number first.
+  wait_stream.AllocateOrderNum(sync_point_manager_.get());
+  release_stream.AllocateOrderNum(sync_point_manager_.get());
+
+  wait_stream.BeginProcessing();
+  int test_num = 10;
+  const bool valid_wait =
+      wait_stream.client->Wait(
+          release_stream.client->client_state(),
+          1,
+          base::Bind(&SyncPointManagerTest::SetIntegerFunction,
+                     &test_num,
+                     123));
+  EXPECT_FALSE(valid_wait);
+  EXPECT_EQ(10, test_num);
+}
+
+TEST_F(SyncPointManagerTest, HigherOrderNumberRelease) {
+  const CommandBufferNamespace kNamespaceId =
+      gpu::CommandBufferNamespace::GPU_IO;
+  const uint64_t kBufferId1 = 0x123;
+  const uint64_t kBufferId2 = 0x234;
+
+  SyncPointStream release_stream(sync_point_manager_.get(),
+                                 kNamespaceId,
+                                 kBufferId1);
+  SyncPointStream wait_stream(sync_point_manager_.get(),
+                              kNamespaceId,
+                              kBufferId2);
+
+  // Generate wait order number first.
+  wait_stream.AllocateOrderNum(sync_point_manager_.get());
+  release_stream.AllocateOrderNum(sync_point_manager_.get());
+
+  // Order number was higher but it was actually released.
+  release_stream.BeginProcessing();
+  release_stream.client->ReleaseFenceSync(1);
+  release_stream.EndProcessing();
+
+  wait_stream.BeginProcessing();
+  int test_num = 10;
+  const bool valid_wait =
+      wait_stream.client->Wait(
+          release_stream.client->client_state(),
+          1,
+          base::Bind(&SyncPointManagerTest::SetIntegerFunction,
+                     &test_num,
+                     123));
+  EXPECT_TRUE(valid_wait);
+  EXPECT_EQ(123, test_num);
+}
+
+TEST_F(SyncPointManagerTest, DestroyedClientRelease) {
+  const CommandBufferNamespace kNamespaceId =
+      gpu::CommandBufferNamespace::GPU_IO;
+  const uint64_t kBufferId1 = 0x123;
+  const uint64_t kBufferId2 = 0x234;
+
+  SyncPointStream release_stream(sync_point_manager_.get(),
+                                 kNamespaceId,
+                                 kBufferId1);
+  SyncPointStream wait_stream(sync_point_manager_.get(),
+                              kNamespaceId,
+                              kBufferId2);
+
+  release_stream.AllocateOrderNum(sync_point_manager_.get());
+  wait_stream.AllocateOrderNum(sync_point_manager_.get());
+
+  wait_stream.BeginProcessing();
+  int test_num = 10;
+  const bool valid_wait =
+      wait_stream.client->Wait(
+          release_stream.client->client_state(),
+          1,
+          base::Bind(&SyncPointManagerTest::SetIntegerFunction,
+                     &test_num,
+                     123));
+  EXPECT_TRUE(valid_wait);
+  EXPECT_EQ(10, test_num);
+
+  // Destroying the client should release the wait.
+  release_stream.client.reset();
+  EXPECT_EQ(123, test_num);
+}
+
+TEST_F(SyncPointManagerTest, NonExistentRelease) {
+  const CommandBufferNamespace kNamespaceId =
+      gpu::CommandBufferNamespace::GPU_IO;
+  const uint64_t kBufferId1 = 0x123;
+  const uint64_t kBufferId2 = 0x234;
+
+  SyncPointStream release_stream(sync_point_manager_.get(),
+                                 kNamespaceId,
+                                 kBufferId1);
+  SyncPointStream wait_stream(sync_point_manager_.get(),
+                              kNamespaceId,
+                              kBufferId2);
+
+  release_stream.AllocateOrderNum(sync_point_manager_.get());
+  wait_stream.AllocateOrderNum(sync_point_manager_.get());
+
+  wait_stream.BeginProcessing();
+  int test_num = 10;
+  const bool valid_wait =
+      wait_stream.client->Wait(
+          release_stream.client->client_state(),
+          1,
+          base::Bind(&SyncPointManagerTest::SetIntegerFunction,
+                     &test_num,
+                     123));
+  EXPECT_TRUE(valid_wait);
+  EXPECT_EQ(10, test_num);
+
+  // No release but finishing the order number should automatically release.
+  release_stream.BeginProcessing();
+  EXPECT_EQ(10, test_num);
+  release_stream.EndProcessing();
+  EXPECT_EQ(123, test_num);
+}
+
+}  // namespace gpu
+