1/*
2 *  Copyright 2014 The WebRTC Project Authors. All rights reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10
11#include <set>
12#include <vector>
13
14#include "webrtc/base/criticalsection.h"
15#include "webrtc/base/event.h"
16#include "webrtc/base/gunit.h"
17#include "webrtc/base/scopedptrcollection.h"
18#include "webrtc/base/thread.h"
19#include "webrtc/test/testsupport/gtest_disable.h"
20
21namespace rtc {
22
23namespace {
24
25const int kLongTime = 10000;  // 10 seconds
26const int kNumThreads = 16;
27const int kOperationsToRun = 1000;
28
29template <class T>
30class AtomicOpRunner : public MessageHandler {
31 public:
32  explicit AtomicOpRunner(int initial_value)
33      : value_(initial_value),
34        threads_active_(0),
35        start_event_(true, false),
36        done_event_(true, false) {}
37
38  int value() const { return value_; }
39
40  bool Run() {
41    // Signal all threads to start.
42    start_event_.Set();
43
44    // Wait for all threads to finish.
45    return done_event_.Wait(kLongTime);
46  }
47
48  void SetExpectedThreadCount(int count) {
49    threads_active_ = count;
50  }
51
52  virtual void OnMessage(Message* msg) {
53    std::vector<int> values;
54    values.reserve(kOperationsToRun);
55
56    // Wait to start.
57    ASSERT_TRUE(start_event_.Wait(kLongTime));
58
59    // Generate a bunch of values by updating value_ atomically.
60    for (int i = 0; i < kOperationsToRun; ++i) {
61      values.push_back(T::AtomicOp(&value_));
62    }
63
64    { // Add them all to the set.
65      CritScope cs(&all_values_crit_);
66      for (size_t i = 0; i < values.size(); ++i) {
67        std::pair<std::set<int>::iterator, bool> result =
68            all_values_.insert(values[i]);
69        // Each value should only be taken by one thread, so if this value
70        // has already been added, something went wrong.
71        EXPECT_TRUE(result.second)
72            << "Thread=" << Thread::Current() << " value=" << values[i];
73      }
74    }
75
76    // Signal that we're done.
77    if (AtomicOps::Decrement(&threads_active_) == 0) {
78      done_event_.Set();
79    }
80  }
81
82 private:
83  int value_;
84  int threads_active_;
85  CriticalSection all_values_crit_;
86  std::set<int> all_values_;
87  Event start_event_;
88  Event done_event_;
89};
90
91struct IncrementOp {
92  static int AtomicOp(int* i) { return AtomicOps::Increment(i); }
93};
94
95struct DecrementOp {
96  static int AtomicOp(int* i) { return AtomicOps::Decrement(i); }
97};
98
99void StartThreads(ScopedPtrCollection<Thread>* threads,
100                  MessageHandler* handler) {
101  for (int i = 0; i < kNumThreads; ++i) {
102    Thread* thread = new Thread();
103    thread->Start();
104    thread->Post(handler);
105    threads->PushBack(thread);
106  }
107}
108
109}  // namespace
110
111TEST(AtomicOpsTest, Simple) {
112  int value = 0;
113  EXPECT_EQ(1, AtomicOps::Increment(&value));
114  EXPECT_EQ(1, value);
115  EXPECT_EQ(2, AtomicOps::Increment(&value));
116  EXPECT_EQ(2, value);
117  EXPECT_EQ(1, AtomicOps::Decrement(&value));
118  EXPECT_EQ(1, value);
119  EXPECT_EQ(0, AtomicOps::Decrement(&value));
120  EXPECT_EQ(0, value);
121}
122
123TEST(AtomicOpsTest, DISABLED_ON_MAC(Increment)) {
124  // Create and start lots of threads.
125  AtomicOpRunner<IncrementOp> runner(0);
126  ScopedPtrCollection<Thread> threads;
127  StartThreads(&threads, &runner);
128  runner.SetExpectedThreadCount(kNumThreads);
129
130  // Release the hounds!
131  EXPECT_TRUE(runner.Run());
132  EXPECT_EQ(kOperationsToRun * kNumThreads, runner.value());
133}
134
135TEST(AtomicOpsTest, DISABLED_ON_MAC(Decrement)) {
136  // Create and start lots of threads.
137  AtomicOpRunner<DecrementOp> runner(kOperationsToRun * kNumThreads);
138  ScopedPtrCollection<Thread> threads;
139  StartThreads(&threads, &runner);
140  runner.SetExpectedThreadCount(kNumThreads);
141
142  // Release the hounds!
143  EXPECT_TRUE(runner.Run());
144  EXPECT_EQ(0, runner.value());
145}
146
147}  // namespace rtc
148