gpu: Reuse transfer buffers more aggresively

gpu/command_buffer/common/gles2_cmd_format_test.cc

 // Copyright (c) 2011 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.
 
 // This file contains unit tests for gles2 commmands
 
+#include <limits>
+
+#include "base/bind.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 
 namespace gpu {
 namespace gles2 {
 
 class GLES2FormatTest : public testing::Test {
  protected:
   static const unsigned char kInitialValue = 0xBD;
 
@@ skipping 22 matching lines @@
 
   void CheckBytesWrittenMatchesExpectedSize(
       const void* end, size_t expected_size) {
     CheckBytesWritten(end, expected_size, expected_size);
   }
 
  private:
   unsigned char buffer_[1024];
 };
 
+void SignalCompletion(uint32* assigned_async_token_ptr,
+                      uint32 async_token,
+                      AsyncUploadSync* sync) {
+  EXPECT_EQ(async_token, *assigned_async_token_ptr);
+  sync->SetAsyncUploadToken(async_token);
+}
+
+TEST(GLES2FormatAsyncUploadSyncTest, AsyncUploadSync) {
+  const size_t kSize = 10;
+  const size_t kCount = 1000;
+
+  base::Thread thread("GLES2FormatUploadSyncTest - Fake Upload Thread");
+  thread.Start();
+
+  // Run the same test 50 times so we retest the wrap as well.
+  for (size_t test_run = 0; test_run < 50; ++test_run) {
+    AsyncUploadSync sync;
+    sync.Reset();
+
+    uint32 buffer_tokens[kSize];
+    memset(buffer_tokens, 0, sizeof(buffer_tokens));
+
+    // Start with a token large enough so that we'll wrap.
+    uint32 async_token = std::numeric_limits<uint32>::max() - kCount / 2;
+
+    // Set initial async token.
+    sync.SetAsyncUploadToken(async_token);
+
+    for (size_t i = 0; i < kCount; ++i) {
+      size_t buffer = i % kSize;
+
+      // Loop until previous async token has passed if any was set.
+      while (buffer_tokens[buffer] &&
+             !sync.HasAsyncUploadTokenPassed(buffer_tokens[buffer]))
+        base::PlatformThread::YieldCurrentThread();
+
+      // Next token, skip 0.
+      async_token++;
+      if (async_token == 0)
+        async_token++;
+
+      // Set the buffer's associated token.
+      buffer_tokens[buffer] = async_token;
+
+      base::subtle::MemoryBarrier();

[piman, 2014/03/20 21:18:26]

Why the barrier? On the contrary, we want to make sure it works without that
barrier (i.e. that HasAsyncUploadTokenPassed has the right Acquire semantic).
Note: the PostTask implies before->after data semantics for buffer_tokens, if
that's what you're concerned about.

[jadahl, 2014/03/21 08:30:53]

I added it to ensure the buffer_tokens[buffer] store, but as you say PostTask
implies it, I will remove the barrier.

+
+      // Set the async upload token on the fake upload thread and assert that
+      // the associated buffer still has the given token.
+      thread.message_loop()->PostTask(FROM_HERE,
+                                      base::Bind(&SignalCompletion,
+                                                 &buffer_tokens[buffer],
+                                                 async_token,
+                                                 &sync));
+    }
+
+    // Flush the thread message loop before starting again.
+    base::WaitableEvent waitable(false, false);
+    thread.message_loop()->PostTask(FROM_HERE,
+                                    base::Bind(&base::WaitableEvent::Signal,
+                                               base::Unretained(&waitable)));
+    waitable.Wait();
+  }
+}
+
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef _MSC_VER
 const unsigned char GLES2FormatTest::kInitialValue;
 #endif
 
 #include "gpu/command_buffer/common/gles2_cmd_format_test_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu