gpu: Reuse transfer buffers more aggresively

gpu/command_buffer/common/gles2_cmd_format.h

 // 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.
 
 // This file defines the GLES2 command buffer commands.
 
 #ifndef GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H_
 #define GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H_
 
 
 #include <KHR/khrplatform.h>
 
 #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"
 #include "gpu/command_buffer/common/types.h"
 
 // GL types are forward declared to avoid including the GL headers. The problem
 // is determining which GL headers to include from code that is common to the
 // client and service sides (GLES2 or one of several GL implementations).
 typedef unsigned int GLenum;
 typedef unsigned int GLbitfield;
@@ skipping 118 matching lines @@
 struct QuerySync {
   void Reset() {
     process_count = 0;
     result = 0;
   }
 
   uint32 process_count;
   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);
 COMPILE_ASSERT(offsetof(ProgramInput, size) == 4,
                OffsetOf_ProgramInput_size_not_4);
 COMPILE_ASSERT(offsetof(ProgramInput, location_offset) == 8,
                OffsetOf_ProgramInput_location_offset_not_8);
 COMPILE_ASSERT(offsetof(ProgramInput, name_offset) == 12,
                OffsetOf_ProgramInput_name_offset_not_12);
 COMPILE_ASSERT(offsetof(ProgramInput, name_length) == 16,
@@ skipping 275 matching lines @@
   CommandHeader header;
 };
 
 #pragma pack(pop)
 
 }  // namespace cmd
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H_