gpu: Reuse transfer buffers more aggresively

gpu/command_buffer/common/gles2_cmd_format.h

Index: gpu/command_buffer/common/gles2_cmd_format.h
diff --git a/gpu/command_buffer/common/gles2_cmd_format.h b/gpu/command_buffer/common/gles2_cmd_format.h
index 252aafd06cf800695b969d1518bb344dcdacfe05..c5637432baccedbcfedcba613e8566a5b4684e86 100644
--- a/gpu/command_buffer/common/gles2_cmd_format.h
+++ b/gpu/command_buffer/common/gles2_cmd_format.h
@@ -12,6 +12,7 @@
 
 #include <string.h>
 
+#include "base/atomicops.h"
 #include "gpu/command_buffer/common/bitfield_helpers.h"
 #include "gpu/command_buffer/common/cmd_buffer_common.h"
 #include "gpu/command_buffer/common/gles2_cmd_ids.h"
@@ -150,6 +151,23 @@ struct QuerySync {
   uint64 result;
 };
 
+struct AsyncUploadSync {
+  void Reset() {
+    base::subtle::Release_Store(&async_upload_token, 0);
+  }
+
+  void SetAsyncUploadToken(uint32 token) {
+    base::subtle::Release_Store(&async_upload_token, token);
+  }
+
+  bool HasAsyncUploadTokenPassed(uint32 token) {
+    uint32_t current_token = base::subtle::Acquire_Load(&async_upload_token);
+    return (current_token - token < 0x80000000);
+  }
+
+  base::subtle::Atomic32 async_upload_token;
+};

[piman, 2014/02/20 01:52:37]

Can we add a unit test for this, that mimics our usage pattern?

Something along the lines of:

void ReadCompareAndSignal(uint32* value, uint32 expected, uint32 token,
AsyncUploadSync* sync) {
  // Simulate a "read" of the shared data, similar to what texture upload would
do
  EXPECT_EQ(expected, *value);
  sync->SetAsyncUploadToken(token);
}

TEST() {
  const size_t kSize = 10;
  const size_t kCount = 10000;  // some value that keeps running time to below
1s or so but making sure its >> kSize so we reuse memory many times.
  AsyncUploadSync sync;
  sync.Reset();
  uint32 token = 0;  // or some value to exercise wrapping.
  scoped_ptr<uint32[]> buffer(new uint32[kSize]);
  scoped_ptr<uint32[]> tokens(new uint32[kSize]);
  memset(tokens.get(), 0, sizeod(uint32[kSize]);
  base::Thread thread("Upload Thread");
  thread.Start();

  for (uint32 i = 0; i < kCount; ++i) {
    size_t offset = i % kSize;
    while (!sync.HasAsyncUploadTokenPassed(tokens[i]))
      PlatformThread::YieldCurrentThread();   // Or something to back off
without explicit synchronization. 

    uint32* data = buffer.get()+offset;
    *data = i;
    ++token;
    tokens[i] = token;
    thread.message_loop()->PostTask(
      FROM_HERE, base::Bind(&ReadCompareAndSignal, data, i, token, &sync));
  }
}

+
 COMPILE_ASSERT(sizeof(ProgramInput) == 20, ProgramInput_size_not_20);
 COMPILE_ASSERT(offsetof(ProgramInput, type) == 0,
                OffsetOf_ProgramInput_type_not_0);