Index: base/task_scheduler/scheduler_lock_unittest.cc |
diff --git a/base/task_scheduler/scheduler_lock_unittest.cc b/base/task_scheduler/scheduler_lock_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..31c5088428ff1bb071971b7e92c3515007782f90 |
--- /dev/null |
+++ b/base/task_scheduler/scheduler_lock_unittest.cc |
@@ -0,0 +1,209 @@ |
+// Copyright 2016 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 "base/task_scheduler/scheduler_lock.h" |
+ |
+#include <stdlib.h> |
+ |
+#include "base/compiler_specific.h" |
+#include "base/macros.h" |
+#include "base/synchronization/waitable_event.h" |
+#include "base/threading/platform_thread.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+ |
+namespace base { |
+namespace internal { |
+ |
+class BasicLockTestThread : public PlatformThread::Delegate { |
gab
2016/02/19 16:08:04
Meta comment on what this does.
robliao
2016/02/19 21:25:07
Done.
|
+ public: |
+ explicit BasicLockTestThread(SchedulerLock* lock) |
+ : lock_(lock), |
+ acquired_(0) {} |
+ |
+ void ThreadMain() override { |
+ for (int i = 0; i < 10; i++) { |
+ lock_->Acquire(); |
+ acquired_++; |
+ lock_->Release(); |
+ } |
+ for (int i = 0; i < 10; i++) { |
+ lock_->Acquire(); |
+ acquired_++; |
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20)); |
gab
2016/02/19 16:08:04
Use base/rand_util.h instead of stdlib's rand()
robliao
2016/02/19 21:25:07
Done.
|
+ lock_->Release(); |
+ } |
+ } |
+ |
+ int acquired() const { return acquired_; } |
+ |
+ private: |
+ SchedulerLock* const lock_; |
+ int acquired_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(BasicLockTestThread); |
+}; |
+ |
+class BasicLockAcquireAndWaitThread : public PlatformThread::Delegate { |
+ public: |
+ explicit BasicLockAcquireAndWaitThread(SchedulerLock* lock) |
+ : lock_(lock), |
+ lock_acquire_event_(false, false), |
+ main_thread_continue_event_(false, false) {} |
+ |
+ void ThreadMain() override { |
+ lock_->Acquire(); |
+ lock_acquire_event_.Signal(); |
+ main_thread_continue_event_.Wait(); |
+ lock_->Release(); |
+ } |
+ |
+ void WaitForLockAcquition() { |
gab
2016/02/19 16:08:03
WaitForLockAcquisition
^
robliao
2016/02/19 21:25:06
Done.
|
+ lock_acquire_event_.Wait(); |
+ } |
+ |
+ void ContinueMain() { |
+ main_thread_continue_event_.Signal(); |
+ } |
+ |
+ private: |
+ SchedulerLock* const lock_; |
+ WaitableEvent lock_acquire_event_; |
+ WaitableEvent main_thread_continue_event_; |
+}; |
gab
2016/02/19 16:08:03
DISALLOW_COPY_AND_ASSIGN
robliao
2016/02/19 21:25:07
Done.
|
+ |
+TEST(TaskSchedulerLock, Basic) { |
+ SchedulerLock lock; |
+ BasicLockTestThread thread(&lock); |
+ PlatformThreadHandle handle; |
+ |
+ ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle)); |
+ |
+ int acquired = 0; |
+ for (int i = 0; i < 5; i++) { |
+ lock.Acquire(); |
+ acquired++; |
+ lock.Release(); |
+ } |
+ for (int i = 0; i < 10; i++) { |
+ lock.Acquire(); |
+ acquired++; |
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20)); |
+ lock.Release(); |
+ } |
+ for (int i = 0; i < 5; i++) { |
+ lock.Acquire(); |
+ acquired++; |
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20)); |
+ lock.Release(); |
+ } |
+ |
+ PlatformThread::Join(handle); |
+ |
+ EXPECT_GE(acquired, 20); |
+ EXPECT_GE(thread.acquired(), 20); |
gab
2016/02/19 16:08:03
Why GE and not EQ? (if EQ, put constant on LHS, pe
robliao
2016/02/19 21:25:07
The original lock test had a try, so there was a c
|
+} |
+ |
+TEST(TaskSchedulerLock, AcquirePredecessor) { |
+ SchedulerLock lock_predecessor; |
+ SchedulerLock lock(&lock_predecessor); |
+ lock_predecessor.Acquire(); |
+ lock.Acquire(); |
+ lock.Release(); |
+ lock_predecessor.Release(); |
+} |
+ |
+TEST(TaskSchedulerLock, AcquireNonPredecessor) { |
+ SchedulerLock lock_predecessor; |
gab
2016/02/19 16:08:03
s/lock_predecessor/other_lock/ (since it's not act
robliao
2016/02/19 21:25:06
Changed to lock1 and lock2 to match below.
|
+ SchedulerLock lock; |
+ EXPECT_DEBUG_DEATH({ |
gab
2016/02/19 16:08:03
Cool :-)!! Didn't know about EXPECT_DEBUG_DEATH!
robliao
2016/02/19 21:25:06
Turns out Release builds for tests don't have DCHE
gab
2016/02/19 22:05:24
Hmmm okay (they probably should and I remember a d
robliao
2016/02/19 23:51:11
The right fix would be to update the EXPECT_DEBUG_
|
+ lock_predecessor.Acquire(); |
+ lock.Acquire(); |
+ lock_predecessor.Release(); |
+ }, ""); |
+} |
+ |
+TEST(TaskSchedulerLock, AcquireMultipleLocksInOrder) { |
+ SchedulerLock lock1; |
+ SchedulerLock lock2(&lock1); |
+ SchedulerLock lock3(&lock2); |
+ lock1.Acquire(); |
+ lock2.Acquire(); |
+ lock3.Acquire(); |
+ lock3.Release(); |
+ lock2.Release(); |
+ lock1.Release(); |
+} |
+ |
+TEST(TaskSchedulerLock, AcquireMultipleLocksInTheMiddleOfAChain) { |
+ SchedulerLock lock1; |
+ SchedulerLock lock2(&lock1); |
+ SchedulerLock lock3(&lock2); |
+ lock2.Acquire(); |
+ lock3.Acquire(); |
+ lock3.Release(); |
+ lock2.Release(); |
+} |
+ |
+TEST(TaskSchedulerLock, AcquireMultipleLocksOutOfOrder) { |
+ SchedulerLock lock1; |
+ SchedulerLock lock2(&lock1); |
+ SchedulerLock lock3(&lock2); |
gab
2016/02/19 16:08:03
Looks like this test only needs two locks. Let's k
robliao
2016/02/19 21:25:06
This is actually a little different from AcquireNo
gab
2016/02/19 22:05:24
Ah I see then I think we also need an "out-of-orde
robliao
2016/02/19 23:51:11
Done.
|
+ EXPECT_DEBUG_DEATH({ |
+ lock1.Acquire(); |
+ lock3.Acquire(); |
gab
2016/02/19 16:08:04
I'd prefer if this was the last statement in the E
robliao
2016/02/19 21:25:06
Done.
|
+ lock1.Release(); |
gab
2016/02/19 16:08:03
In non-dcheck builds you have to Release lock3 or
robliao
2016/02/19 21:25:07
Turns out, this is okay due to forking on non-Wind
|
+ }, ""); |
+} |
+ |
+TEST(TaskSchedulerLock, AcquireLocksDifferentThreadsSafely) { |
+ SchedulerLock lock1; |
+ SchedulerLock lock2; |
+ BasicLockAcquireAndWaitThread thread(&lock1); |
+ PlatformThreadHandle handle; |
+ ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle)); |
+ |
+ lock2.Acquire(); |
+ thread.WaitForLockAcquition(); |
+ thread.ContinueMain(); |
+ lock2.Release(); |
+ PlatformThread::Join(handle); |
+} |
+ |
+TEST(TaskSchedulerLock, AcquireLocksWithPredecessorDifferentThreadsSafely) { |
+ SchedulerLock lock1; |
+ SchedulerLock lock2(&lock1); |
+ BasicLockAcquireAndWaitThread thread(&lock1); |
+ PlatformThreadHandle handle; |
+ ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle)); |
+ |
gab
2016/02/19 16:08:03
Think we also need
thread.ContinueAcquireLock();
t
robliao
2016/02/19 21:25:06
Clarified the test and added explicit locking orde
|
+ lock2.Acquire(); |
+ thread.WaitForLockAcquition(); |
+ thread.ContinueMain(); |
+ lock2.Release(); |
+ PlatformThread::Join(handle); |
+} |
+ |
+TEST(TaskSchedulerLock, SelfReferentialLock) { |
+ struct SelfReferentialLock { |
+ SelfReferentialLock() : lock(&lock) {} |
+ |
+ SchedulerLock lock; |
+ }; |
+ |
+ EXPECT_DEBUG_DEATH({ SelfReferentialLock lock; }, ""); |
+} |
+ |
+TEST(TaskSchedulerLock, PredecessorCycle) { |
+ struct LockCycle { |
+ LockCycle() : lock1(&lock2), lock2(&lock1) {} |
+ |
+ SchedulerLock lock1; |
+ SchedulerLock lock2; |
+ }; |
+ |
+ EXPECT_DEBUG_DEATH({ LockCycle cycle; }, ""); |
+} |
+ |
gab
2016/02/19 16:08:04
Ah interesting :-), thought taking predecessor as
robliao
2016/02/19 21:25:07
Done.
|
+} // namespace internal |
+} // base |