rtc_base/criticalsection_unittest.cc - src/webrtc - Git at Google

 /*
  *  Copyright 2014 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */

 #include <memory>
 #include <set>
 #include <vector>

 #include "webrtc/rtc_base/arraysize.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/criticalsection.h"
 #include "webrtc/rtc_base/event.h"
 #include "webrtc/rtc_base/gunit.h"
 #include "webrtc/rtc_base/platform_thread.h"
 #include "webrtc/rtc_base/thread.h"

 namespace rtc {

 namespace {

 const int kLongTime = 10000;  // 10 seconds
 const int kNumThreads = 16;
 const int kOperationsToRun = 1000;

 class UniqueValueVerifier {
  public:
   void Verify(const std::vector<int>& values) {
     for (size_t i = 0; i < values.size(); ++i) {
       std::pair<std::set<int>::iterator, bool> result =
           all_values_.insert(values[i]);
       // Each value should only be taken by one thread, so if this value
       // has already been added, something went wrong.
       EXPECT_TRUE(result.second)
           << " Thread=" << Thread::Current() << " value=" << values[i];
     }
   }

   void Finalize() {}

  private:
   std::set<int> all_values_;
 };

 class CompareAndSwapVerifier {
  public:
   CompareAndSwapVerifier() : zero_count_(0) {}

   void Verify(const std::vector<int>& values) {
     for (auto v : values) {
       if (v == 0) {
         EXPECT_EQ(0, zero_count_) << "Thread=" << Thread::Current();
         ++zero_count_;
       } else {
         EXPECT_EQ(1, v) << " Thread=" << Thread::Current();
       }
     }
   }

   void Finalize() {
     EXPECT_EQ(1, zero_count_);
   }
  private:
   int zero_count_;
 };

 class RunnerBase : public MessageHandler {
  public:
   explicit RunnerBase(int value)
       : threads_active_(0),
         start_event_(true, false),
         done_event_(true, false),
         shared_value_(value) {}

   bool Run() {
     // Signal all threads to start.
     start_event_.Set();

     // Wait for all threads to finish.
     return done_event_.Wait(kLongTime);
   }

   void SetExpectedThreadCount(int count) {
     threads_active_ = count;
   }

   int shared_value() const { return shared_value_; }

  protected:
   // Derived classes must override OnMessage, and call BeforeStart and AfterEnd
   // at the beginning and the end of OnMessage respectively.
   void BeforeStart() {
     ASSERT_TRUE(start_event_.Wait(kLongTime));
   }

   // Returns true if all threads have finished.
   bool AfterEnd() {
     if (AtomicOps::Decrement(&threads_active_) == 0) {
       done_event_.Set();
       return true;
     }
     return false;
   }

   int threads_active_;
   Event start_event_;
   Event done_event_;
   int shared_value_;
 };

 class LOCKABLE CriticalSectionLock {
  public:
   void Lock() EXCLUSIVE_LOCK_FUNCTION() {
     cs_.Enter();
   }
   void Unlock() UNLOCK_FUNCTION() {
     cs_.Leave();
   }

  private:
   CriticalSection cs_;
 };

 template <class Lock>
 class LockRunner : public RunnerBase {
  public:
   LockRunner() : RunnerBase(0) {}

   void OnMessage(Message* msg) override {
     BeforeStart();

     lock_.Lock();

     EXPECT_EQ(0, shared_value_);
     int old = shared_value_;

     // Use a loop to increase the chance of race.
     for (int i = 0; i < kOperationsToRun; ++i) {
       ++shared_value_;
     }
     EXPECT_EQ(old + kOperationsToRun, shared_value_);
     shared_value_ = 0;

     lock_.Unlock();

     AfterEnd();
   }

  private:
   Lock lock_;
 };

 template <class Op, class Verifier>
 class AtomicOpRunner : public RunnerBase {
  public:
   explicit AtomicOpRunner(int initial_value) : RunnerBase(initial_value) {}

   void OnMessage(Message* msg) override {
     BeforeStart();

     std::vector<int> values;
     values.reserve(kOperationsToRun);

     // Generate a bunch of values by updating shared_value_ atomically.
     for (int i = 0; i < kOperationsToRun; ++i) {
       values.push_back(Op::AtomicOp(&shared_value_));
     }

     { // Add them all to the set.
       CritScope cs(&all_values_crit_);
       verifier_.Verify(values);
     }

     if (AfterEnd()) {
       verifier_.Finalize();
     }
   }

  private:
   CriticalSection all_values_crit_;
   Verifier verifier_;
 };

 struct IncrementOp {
   static int AtomicOp(int* i) { return AtomicOps::Increment(i); }
 };

 struct DecrementOp {
   static int AtomicOp(int* i) { return AtomicOps::Decrement(i); }
 };

 struct CompareAndSwapOp {
   static int AtomicOp(int* i) { return AtomicOps::CompareAndSwap(i, 0, 1); }
 };

 void StartThreads(std::vector<std::unique_ptr<Thread>>* threads,
                   MessageHandler* handler) {
   for (int i = 0; i < kNumThreads; ++i) {
     std::unique_ptr<Thread> thread(Thread::Create());
     thread->Start();
     thread->Post(RTC_FROM_HERE, handler);
     threads->push_back(std::move(thread));
   }
 }

 }  // namespace

 TEST(AtomicOpsTest, Simple) {
   int value = 0;
   EXPECT_EQ(1, AtomicOps::Increment(&value));
   EXPECT_EQ(1, value);
   EXPECT_EQ(2, AtomicOps::Increment(&value));
   EXPECT_EQ(2, value);
   EXPECT_EQ(1, AtomicOps::Decrement(&value));
   EXPECT_EQ(1, value);
   EXPECT_EQ(0, AtomicOps::Decrement(&value));
   EXPECT_EQ(0, value);
 }

 TEST(AtomicOpsTest, SimplePtr) {
   class Foo {};
   Foo* volatile foo = nullptr;
   std::unique_ptr<Foo> a(new Foo());
   std::unique_ptr<Foo> b(new Foo());
   // Reading the initial value should work as expected.
   EXPECT_TRUE(rtc::AtomicOps::AcquireLoadPtr(&foo) == nullptr);
   // Setting using compare and swap should work.
   EXPECT_TRUE(rtc::AtomicOps::CompareAndSwapPtr(
                   &foo, static_cast<Foo*>(nullptr), a.get()) == nullptr);
   EXPECT_TRUE(rtc::AtomicOps::AcquireLoadPtr(&foo) == a.get());
   // Setting another value but with the wrong previous pointer should fail
   // (remain a).
   EXPECT_TRUE(rtc::AtomicOps::CompareAndSwapPtr(
                   &foo, static_cast<Foo*>(nullptr), b.get()) == a.get());
   EXPECT_TRUE(rtc::AtomicOps::AcquireLoadPtr(&foo) == a.get());
   // Replacing a with b should work.
   EXPECT_TRUE(rtc::AtomicOps::CompareAndSwapPtr(&foo, a.get(), b.get()) ==
               a.get());
   EXPECT_TRUE(rtc::AtomicOps::AcquireLoadPtr(&foo) == b.get());
 }

 TEST(AtomicOpsTest, Increment) {
   // Create and start lots of threads.
   AtomicOpRunner<IncrementOp, UniqueValueVerifier> runner(0);
   std::vector<std::unique_ptr<Thread>> threads;
   StartThreads(&threads, &runner);
   runner.SetExpectedThreadCount(kNumThreads);

   // Release the hounds!
   EXPECT_TRUE(runner.Run());
   EXPECT_EQ(kOperationsToRun * kNumThreads, runner.shared_value());
 }

 TEST(AtomicOpsTest, Decrement) {
   // Create and start lots of threads.
   AtomicOpRunner<DecrementOp, UniqueValueVerifier> runner(
       kOperationsToRun * kNumThreads);
   std::vector<std::unique_ptr<Thread>> threads;
   StartThreads(&threads, &runner);
   runner.SetExpectedThreadCount(kNumThreads);

   // Release the hounds!
   EXPECT_TRUE(runner.Run());
   EXPECT_EQ(0, runner.shared_value());
 }

 TEST(AtomicOpsTest, CompareAndSwap) {
   // Create and start lots of threads.
   AtomicOpRunner<CompareAndSwapOp, CompareAndSwapVerifier> runner(0);
   std::vector<std::unique_ptr<Thread>> threads;
   StartThreads(&threads, &runner);
   runner.SetExpectedThreadCount(kNumThreads);

   // Release the hounds!
   EXPECT_TRUE(runner.Run());
   EXPECT_EQ(1, runner.shared_value());
 }

 TEST(GlobalLockTest, Basic) {
   // Create and start lots of threads.
   LockRunner<GlobalLock> runner;
   std::vector<std::unique_ptr<Thread>> threads;
   StartThreads(&threads, &runner);
   runner.SetExpectedThreadCount(kNumThreads);

   // Release the hounds!
   EXPECT_TRUE(runner.Run());
   EXPECT_EQ(0, runner.shared_value());
 }

 TEST(CriticalSectionTest, Basic) {
   // Create and start lots of threads.
   LockRunner<CriticalSectionLock> runner;
   std::vector<std::unique_ptr<Thread>> threads;
   StartThreads(&threads, &runner);
   runner.SetExpectedThreadCount(kNumThreads);

   // Release the hounds!
   EXPECT_TRUE(runner.Run());
   EXPECT_EQ(0, runner.shared_value());
 }

 class PerfTestData {
  public:
   PerfTestData(int expected_count, Event* event)
       : cache_line_barrier_1_(), cache_line_barrier_2_(),
         expected_count_(expected_count), event_(event) {
     cache_line_barrier_1_[0]++;  // Avoid 'is not used'.
     cache_line_barrier_2_[0]++;  // Avoid 'is not used'.
   }
   ~PerfTestData() {}

   void AddToCounter(int add) {
     rtc::CritScope cs(&lock_);
     my_counter_ += add;
     if (my_counter_ == expected_count_)
       event_->Set();
   }

   int64_t total() const {
     // Assume that only one thread is running now.
     return my_counter_;
   }

  private:
   uint8_t cache_line_barrier_1_[64];
   CriticalSection lock_;
   uint8_t cache_line_barrier_2_[64];
   int64_t my_counter_ = 0;
   const int expected_count_;
   Event* const event_;
 };

 class PerfTestThread {
  public:
   PerfTestThread() : thread_(&ThreadFunc, this, "CsPerf") {}

   void Start(PerfTestData* data, int repeats, int id) {
     RTC_DCHECK(!thread_.IsRunning());
     RTC_DCHECK(!data_);
     data_ = data;
     repeats_ = repeats;
     my_id_ = id;
     thread_.Start();
   }

   void Stop() {
     RTC_DCHECK(thread_.IsRunning());
     RTC_DCHECK(data_);
     thread_.Stop();
     repeats_ = 0;
     data_ = nullptr;
     my_id_ = 0;
   }

  private:
   static bool ThreadFunc(void* param) {
     PerfTestThread* me = static_cast<PerfTestThread*>(param);
     for (int i = 0; i < me->repeats_; ++i)
       me->data_->AddToCounter(me->my_id_);
     return false;
   }

   PlatformThread thread_;
   PerfTestData* data_ = nullptr;
   int repeats_ = 0;
   int my_id_ = 0;
 };

 // Comparison of output of this test as tested on a MacBook Pro Retina, 15-inch,
 // Mid 2014, 2,8 GHz Intel Core i7, 16 GB 1600 MHz DDR3,
 // running OS X El Capitan, 10.11.2.
 //
 // Native mutex implementation:
 // Approximate CPU usage:
 //   System: ~16%
 //   User mode: ~1.3%
 //   Idle: ~82%
 // Unit test output:
 // [       OK ] CriticalSectionTest.Performance (234545 ms)
 //
 // Special partially spin lock based implementation:
 // Approximate CPU usage:
 //   System: ~75%
 //   User mode: ~16%
 //   Idle: ~8%
 // Unit test output:
 // [       OK ] CriticalSectionTest.Performance (2107 ms)
 //
 // The test is disabled by default to avoid unecessarily loading the bots.
 TEST(CriticalSectionTest, DISABLED_Performance) {
   PerfTestThread threads[8];
   Event event(false, false);

   static const int kThreadRepeats = 10000000;
   static const int kExpectedCount = kThreadRepeats * arraysize(threads);
   PerfTestData test_data(kExpectedCount, &event);

   for (auto& t : threads)
     t.Start(&test_data, kThreadRepeats, 1);

   event.Wait(Event::kForever);

   for (auto& t : threads)
     t.Stop();
 }

 }  // namespace rtc
	/*
	* Copyright 2014 The WebRTC Project Authors. All rights reserved.
	*
	* Use of this source code is governed by a BSD-style license
	* that can be found in the LICENSE file in the root of the source
	* tree. An additional intellectual property rights grant can be found
	* in the file PATENTS. All contributing project authors may
	* be found in the AUTHORS file in the root of the source tree.
	*/

	#include <memory>
	#include <set>
	#include <vector>

	#include "webrtc/rtc_base/arraysize.h"
	#include "webrtc/rtc_base/checks.h"
	#include "webrtc/rtc_base/criticalsection.h"
	#include "webrtc/rtc_base/event.h"
	#include "webrtc/rtc_base/gunit.h"
	#include "webrtc/rtc_base/platform_thread.h"
	#include "webrtc/rtc_base/thread.h"

	namespace rtc {

	namespace {

	const int kLongTime = 10000; // 10 seconds
	const int kNumThreads = 16;
	const int kOperationsToRun = 1000;

	class UniqueValueVerifier {
	public:
	void Verify(const std::vector<int>& values) {
	for (size_t i = 0; i < values.size(); ++i) {
	std::pair<std::set<int>::iterator, bool> result =
	all_values_.insert(values[i]);
	// Each value should only be taken by one thread, so if this value
	// has already been added, something went wrong.
	EXPECT_TRUE(result.second)
	<< " Thread=" << Thread::Current() << " value=" << values[i];
	}
	}

	void Finalize() {}

	private:
	std::set<int> all_values_;
	};

	class CompareAndSwapVerifier {
	public:
	CompareAndSwapVerifier() : zero_count_(0) {}

	void Verify(const std::vector<int>& values) {
	for (auto v : values) {
	if (v == 0) {
	EXPECT_EQ(0, zero_count_) << "Thread=" << Thread::Current();
	++zero_count_;
	} else {
	EXPECT_EQ(1, v) << " Thread=" << Thread::Current();
	}
	}
	}

	void Finalize() {
	EXPECT_EQ(1, zero_count_);
	}
	private:
	int zero_count_;
	};

	class RunnerBase : public MessageHandler {
	public:
	explicit RunnerBase(int value)
	: threads_active_(0),
	start_event_(true, false),
	done_event_(true, false),
	shared_value_(value) {}

	bool Run() {
	// Signal all threads to start.
	start_event_.Set();

	// Wait for all threads to finish.
	return done_event_.Wait(kLongTime);
	}

	void SetExpectedThreadCount(int count) {
	threads_active_ = count;
	}

	int shared_value() const { return shared_value_; }

	protected:
	// Derived classes must override OnMessage, and call BeforeStart and AfterEnd
	// at the beginning and the end of OnMessage respectively.
	void BeforeStart() {
	ASSERT_TRUE(start_event_.Wait(kLongTime));
	}

	// Returns true if all threads have finished.
	bool AfterEnd() {
	if (AtomicOps::Decrement(&threads_active_) == 0) {
	done_event_.Set();
	return true;
	}
	return false;
	}

	int threads_active_;
	Event start_event_;
	Event done_event_;
	int shared_value_;
	};

	class LOCKABLE CriticalSectionLock {
	public:
	void Lock() EXCLUSIVE_LOCK_FUNCTION() {
	cs_.Enter();
	}
	void Unlock() UNLOCK_FUNCTION() {
	cs_.Leave();
	}

	private:
	CriticalSection cs_;
	};

	template <class Lock>
	class LockRunner : public RunnerBase {
	public:
	LockRunner() : RunnerBase(0) {}

	void OnMessage(Message* msg) override {
	BeforeStart();

	lock_.Lock();

	EXPECT_EQ(0, shared_value_);
	int old = shared_value_;

	// Use a loop to increase the chance of race.
	for (int i = 0; i < kOperationsToRun; ++i) {
	++shared_value_;
	}
	EXPECT_EQ(old + kOperationsToRun, shared_value_);
	shared_value_ = 0;

	lock_.Unlock();

	AfterEnd();
	}

	private:
	Lock lock_;
	};

	template <class Op, class Verifier>
	class AtomicOpRunner : public RunnerBase {
	public:
	explicit AtomicOpRunner(int initial_value) : RunnerBase(initial_value) {}

	void OnMessage(Message* msg) override {
	BeforeStart();

	std::vector<int> values;
	values.reserve(kOperationsToRun);

	// Generate a bunch of values by updating shared_value_ atomically.
	for (int i = 0; i < kOperationsToRun; ++i) {
	values.push_back(Op::AtomicOp(&shared_value_));
	}

	{ // Add them all to the set.
	CritScope cs(&all_values_crit_);
	verifier_.Verify(values);
	}

	if (AfterEnd()) {
	verifier_.Finalize();
	}
	}

	private:
	CriticalSection all_values_crit_;
	Verifier verifier_;
	};

	struct IncrementOp {
	static int AtomicOp(int* i) { return AtomicOps::Increment(i); }
	};

	struct DecrementOp {
	static int AtomicOp(int* i) { return AtomicOps::Decrement(i); }
	};

	struct CompareAndSwapOp {
	static int AtomicOp(int* i) { return AtomicOps::CompareAndSwap(i, 0, 1); }
	};

	void StartThreads(std::vector<std::unique_ptr<Thread>>* threads,
	MessageHandler* handler) {
	for (int i = 0; i < kNumThreads; ++i) {
	std::unique_ptr<Thread> thread(Thread::Create());
	thread->Start();
	thread->Post(RTC_FROM_HERE, handler);
	threads->push_back(std::move(thread));
	}
	}

	} // namespace

	TEST(AtomicOpsTest, Simple) {
	int value = 0;
	EXPECT_EQ(1, AtomicOps::Increment(&value));
	EXPECT_EQ(1, value);
	EXPECT_EQ(2, AtomicOps::Increment(&value));
	EXPECT_EQ(2, value);
	EXPECT_EQ(1, AtomicOps::Decrement(&value));
	EXPECT_EQ(1, value);
	EXPECT_EQ(0, AtomicOps::Decrement(&value));
	EXPECT_EQ(0, value);
	}

	TEST(AtomicOpsTest, SimplePtr) {
	class Foo {};
	Foo* volatile foo = nullptr;
	std::unique_ptr<Foo> a(new Foo());
	std::unique_ptr<Foo> b(new Foo());
	// Reading the initial value should work as expected.
	EXPECT_TRUE(rtc::AtomicOps::AcquireLoadPtr(&foo) == nullptr);
	// Setting using compare and swap should work.
	EXPECT_TRUE(rtc::AtomicOps::CompareAndSwapPtr(
	&foo, static_cast<Foo*>(nullptr), a.get()) == nullptr);
	EXPECT_TRUE(rtc::AtomicOps::AcquireLoadPtr(&foo) == a.get());
	// Setting another value but with the wrong previous pointer should fail
	// (remain a).
	EXPECT_TRUE(rtc::AtomicOps::CompareAndSwapPtr(
	&foo, static_cast<Foo*>(nullptr), b.get()) == a.get());
	EXPECT_TRUE(rtc::AtomicOps::AcquireLoadPtr(&foo) == a.get());
	// Replacing a with b should work.
	EXPECT_TRUE(rtc::AtomicOps::CompareAndSwapPtr(&foo, a.get(), b.get()) ==
	a.get());
	EXPECT_TRUE(rtc::AtomicOps::AcquireLoadPtr(&foo) == b.get());
	}

	TEST(AtomicOpsTest, Increment) {
	// Create and start lots of threads.
	AtomicOpRunner<IncrementOp, UniqueValueVerifier> runner(0);
	std::vector<std::unique_ptr<Thread>> threads;
	StartThreads(&threads, &runner);
	runner.SetExpectedThreadCount(kNumThreads);

	// Release the hounds!
	EXPECT_TRUE(runner.Run());
	EXPECT_EQ(kOperationsToRun * kNumThreads, runner.shared_value());
	}

	TEST(AtomicOpsTest, Decrement) {
	// Create and start lots of threads.
	AtomicOpRunner<DecrementOp, UniqueValueVerifier> runner(
	kOperationsToRun * kNumThreads);
	std::vector<std::unique_ptr<Thread>> threads;
	StartThreads(&threads, &runner);
	runner.SetExpectedThreadCount(kNumThreads);

	// Release the hounds!
	EXPECT_TRUE(runner.Run());
	EXPECT_EQ(0, runner.shared_value());
	}

	TEST(AtomicOpsTest, CompareAndSwap) {
	// Create and start lots of threads.
	AtomicOpRunner<CompareAndSwapOp, CompareAndSwapVerifier> runner(0);
	std::vector<std::unique_ptr<Thread>> threads;
	StartThreads(&threads, &runner);
	runner.SetExpectedThreadCount(kNumThreads);

	// Release the hounds!
	EXPECT_TRUE(runner.Run());
	EXPECT_EQ(1, runner.shared_value());
	}

	TEST(GlobalLockTest, Basic) {
	// Create and start lots of threads.
	LockRunner<GlobalLock> runner;
	std::vector<std::unique_ptr<Thread>> threads;
	StartThreads(&threads, &runner);
	runner.SetExpectedThreadCount(kNumThreads);

	// Release the hounds!
	EXPECT_TRUE(runner.Run());
	EXPECT_EQ(0, runner.shared_value());
	}

	TEST(CriticalSectionTest, Basic) {
	// Create and start lots of threads.
	LockRunner<CriticalSectionLock> runner;
	std::vector<std::unique_ptr<Thread>> threads;
	StartThreads(&threads, &runner);
	runner.SetExpectedThreadCount(kNumThreads);

	// Release the hounds!
	EXPECT_TRUE(runner.Run());
	EXPECT_EQ(0, runner.shared_value());
	}

	class PerfTestData {
	public:
	PerfTestData(int expected_count, Event* event)
	: cache_line_barrier_1_(), cache_line_barrier_2_(),
	expected_count_(expected_count), event_(event) {
	cache_line_barrier_1_[0]++; // Avoid 'is not used'.
	cache_line_barrier_2_[0]++; // Avoid 'is not used'.
	}
	~PerfTestData() {}

	void AddToCounter(int add) {
	rtc::CritScope cs(&lock_);
	my_counter_ += add;
	if (my_counter_ == expected_count_)
	event_->Set();
	}

	int64_t total() const {
	// Assume that only one thread is running now.
	return my_counter_;
	}

	private:
	uint8_t cache_line_barrier_1_[64];
	CriticalSection lock_;
	uint8_t cache_line_barrier_2_[64];
	int64_t my_counter_ = 0;
	const int expected_count_;
	Event* const event_;
	};

	class PerfTestThread {
	public:
	PerfTestThread() : thread_(&ThreadFunc, this, "CsPerf") {}

	void Start(PerfTestData* data, int repeats, int id) {
	RTC_DCHECK(!thread_.IsRunning());
	RTC_DCHECK(!data_);
	data_ = data;
	repeats_ = repeats;
	my_id_ = id;
	thread_.Start();
	}

	void Stop() {
	RTC_DCHECK(thread_.IsRunning());
	RTC_DCHECK(data_);
	thread_.Stop();
	repeats_ = 0;
	data_ = nullptr;
	my_id_ = 0;
	}

	private:
	static bool ThreadFunc(void* param) {
	PerfTestThread* me = static_cast<PerfTestThread*>(param);
	for (int i = 0; i < me->repeats_; ++i)
	me->data_->AddToCounter(me->my_id_);
	return false;
	}

	PlatformThread thread_;
	PerfTestData* data_ = nullptr;
	int repeats_ = 0;
	int my_id_ = 0;
	};

	// Comparison of output of this test as tested on a MacBook Pro Retina, 15-inch,
	// Mid 2014, 2,8 GHz Intel Core i7, 16 GB 1600 MHz DDR3,
	// running OS X El Capitan, 10.11.2.
	//
	// Native mutex implementation:
	// Approximate CPU usage:
	// System: ~16%
	// User mode: ~1.3%
	// Idle: ~82%
	// Unit test output:
	// [ OK ] CriticalSectionTest.Performance (234545 ms)
	//
	// Special partially spin lock based implementation:
	// Approximate CPU usage:
	// System: ~75%
	// User mode: ~16%
	// Idle: ~8%
	// Unit test output:
	// [ OK ] CriticalSectionTest.Performance (2107 ms)
	//
	// The test is disabled by default to avoid unecessarily loading the bots.
	TEST(CriticalSectionTest, DISABLED_Performance) {
	PerfTestThread threads[8];
	Event event(false, false);

	static const int kThreadRepeats = 10000000;
	static const int kExpectedCount = kThreadRepeats * arraysize(threads);
	PerfTestData test_data(kExpectedCount, &event);

	for (auto& t : threads)
	t.Start(&test_data, kThreadRepeats, 1);

	event.Wait(Event::kForever);

	for (auto& t : threads)
	t.Stop();
	}

	} // namespace rtc