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
21 namespace rtc {
22
23 namespace {
24
25 const int kLongTime = 10000; // 10 seconds
26 const int kNumThreads = 16;
27 const int kOperationsToRun = 1000;
28
29 template <class T>
30 class AtomicOpRunner : public MessageHandler {
31 public:
AtomicOpRunner(int initial_value)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
value() const38 int value() const { return value_; }
39
Run()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
SetExpectedThreadCount(int count)48 void SetExpectedThreadCount(int count) {
49 threads_active_ = count;
50 }
51
OnMessage(Message * msg)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
91 struct IncrementOp {
AtomicOprtc::__anonbe9107ee0111::IncrementOp92 static int AtomicOp(int* i) { return AtomicOps::Increment(i); }
93 };
94
95 struct DecrementOp {
AtomicOprtc::__anonbe9107ee0111::DecrementOp96 static int AtomicOp(int* i) { return AtomicOps::Decrement(i); }
97 };
98
StartThreads(ScopedPtrCollection<Thread> * threads,MessageHandler * handler)99 void 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
TEST(AtomicOpsTest,Simple)111 TEST(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
TEST(AtomicOpsTest,DISABLED_ON_MAC (Increment))123 TEST(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
TEST(AtomicOpsTest,DISABLED_ON_MAC (Decrement))135 TEST(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