Renderer reading side of gamepad

content/common/gamepad_seqlock_unittest.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.
+
+#include <stdlib.h>
+
+#include "content/common/gamepad_seqlock.h"
+#include "base/threading/platform_thread.h"
+#include "base/third_party/dynamic_annotations/dynamic_annotations.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+
+// Basic test to make sure that basic operation works correctly.
+
+struct TestData {
+  unsigned a, b, c;
+};
+
+class BasicSeqLockTestThread : public PlatformThread::Delegate {
+ public:
+  BasicSeqLockTestThread() {}
+
+  void Init(
+      gamepad::GamepadSeqLock* seqlock,
+      TestData* data,
+      base::subtle::Atomic32* ready) {
+    seqlock_ = seqlock;
+    data_ = data;
+    ready_ = ready;
+  }
+  virtual void ThreadMain() {
+    while (base::subtle::Acquire_Load(ready_) == 0) {}
+
+    for (unsigned i = 0; i < 10000; ++i) {
+      TestData copy;
+      base::subtle::Atomic32 version;
+      do {
+        version = seqlock_->ReadBegin();
+        copy = *data_;
+      } while (seqlock_->ReadRetry(version));
+
+      EXPECT_EQ(copy.a + 100, copy.b);
+      EXPECT_EQ(copy.c, copy.b + copy.a);
+    }
+
+    base::subtle::Barrier_AtomicIncrement(ready_, -1);
+  }
+
+ private:
+  gamepad::GamepadSeqLock* seqlock_;
+  TestData* data_;
+  base::subtle::Atomic32* ready_;
+
+  DISALLOW_COPY_AND_ASSIGN(BasicSeqLockTestThread);
+};
+
+TEST(GamepadSeqLockTest, ManyThreads) {
+  gamepad::GamepadSeqLock seqlock;
+  TestData data = { 0, 0, 0 };
+  base::subtle::Atomic32 ready = 0;
+
+  ANNOTATE_BENIGN_RACE_SIZED(&data, sizeof(data), "Racey reads are discarded");
+
+  static const unsigned kNumReaderThreads = 100;
+  BasicSeqLockTestThread threads[kNumReaderThreads];
+  PlatformThreadHandle handles[kNumReaderThreads];
+
+  for (unsigned i = 0; i < kNumReaderThreads; ++i)
+    threads[i].Init(&seqlock, &data, &ready);
+  for (unsigned i = 0; i < kNumReaderThreads; ++i)
+    ASSERT_TRUE(PlatformThread::Create(0, &threads[i], &handles[i]));
+
+  // The main thread is the writer, and the spawned are readers.
+  unsigned counter = 0;
+  for (;;) {
+    seqlock.WriteBegin();
+    data.a = counter++;
+    data.b = data.a + 100;
+    data.c = data.b + data.a;
+    seqlock.WriteEnd();
+
+    if (counter == 1)
+      base::subtle::Release_Store(&ready, kNumReaderThreads);

[darin (slow to review), 2011/11/30 18:34:37]

Would it be possible to implement |ready| using atomic_ref_count.h instead? 
That might help make this code easier to understand.  As is, I'm forced to fully
internalize the base::subtle:: methods in order to read this code, but if you
can express this just in terms of reference counting, then it might make the
code more readable.

[scottmg, 2011/11/30 19:43:31]

Better, thanks. Done.

+
+    if (base::subtle::Acquire_Load(&ready) == 0)
+      break;
+  }
+
+  for (unsigned i = 0; i < kNumReaderThreads; ++i)
+    PlatformThread::Join(handles[i]);
+}
+
+}  // namespace base