Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 1 | // Copyright 2014 the V8 project authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include <cstring> |
| 6 | |
| 7 | #include "src/base/platform/platform.h" |
| 8 | #include "src/base/platform/semaphore.h" |
| 9 | #include "src/base/platform/time.h" |
| 10 | #include "testing/gtest/include/gtest/gtest.h" |
| 11 | |
| 12 | namespace v8 { |
| 13 | namespace base { |
| 14 | |
| 15 | namespace { |
| 16 | |
| 17 | static const char kAlphabet[] = "XKOAD"; |
| 18 | static const size_t kAlphabetSize = sizeof(kAlphabet) - 1; |
| 19 | static const size_t kBufferSize = 987; // GCD(buffer size, alphabet size) = 1 |
| 20 | static const size_t kDataSize = kBufferSize * kAlphabetSize * 10; |
| 21 | |
| 22 | |
| 23 | class ProducerThread FINAL : public Thread { |
| 24 | public: |
| 25 | ProducerThread(char* buffer, Semaphore* free_space, Semaphore* used_space) |
| 26 | : Thread(Options("ProducerThread")), |
| 27 | buffer_(buffer), |
| 28 | free_space_(free_space), |
| 29 | used_space_(used_space) {} |
| 30 | virtual ~ProducerThread() {} |
| 31 | |
| 32 | virtual void Run() OVERRIDE { |
| 33 | for (size_t n = 0; n < kDataSize; ++n) { |
| 34 | free_space_->Wait(); |
| 35 | buffer_[n % kBufferSize] = kAlphabet[n % kAlphabetSize]; |
| 36 | used_space_->Signal(); |
| 37 | } |
| 38 | } |
| 39 | |
| 40 | private: |
| 41 | char* buffer_; |
| 42 | Semaphore* const free_space_; |
| 43 | Semaphore* const used_space_; |
| 44 | }; |
| 45 | |
| 46 | |
| 47 | class ConsumerThread FINAL : public Thread { |
| 48 | public: |
| 49 | ConsumerThread(const char* buffer, Semaphore* free_space, |
| 50 | Semaphore* used_space) |
| 51 | : Thread(Options("ConsumerThread")), |
| 52 | buffer_(buffer), |
| 53 | free_space_(free_space), |
| 54 | used_space_(used_space) {} |
| 55 | virtual ~ConsumerThread() {} |
| 56 | |
| 57 | virtual void Run() OVERRIDE { |
| 58 | for (size_t n = 0; n < kDataSize; ++n) { |
| 59 | used_space_->Wait(); |
| 60 | EXPECT_EQ(kAlphabet[n % kAlphabetSize], buffer_[n % kBufferSize]); |
| 61 | free_space_->Signal(); |
| 62 | } |
| 63 | } |
| 64 | |
| 65 | private: |
| 66 | const char* buffer_; |
| 67 | Semaphore* const free_space_; |
| 68 | Semaphore* const used_space_; |
| 69 | }; |
| 70 | |
| 71 | |
| 72 | class WaitAndSignalThread FINAL : public Thread { |
| 73 | public: |
| 74 | explicit WaitAndSignalThread(Semaphore* semaphore) |
| 75 | : Thread(Options("WaitAndSignalThread")), semaphore_(semaphore) {} |
| 76 | virtual ~WaitAndSignalThread() {} |
| 77 | |
| 78 | virtual void Run() OVERRIDE { |
| 79 | for (int n = 0; n < 100; ++n) { |
| 80 | semaphore_->Wait(); |
| 81 | ASSERT_FALSE(semaphore_->WaitFor(TimeDelta::FromMicroseconds(1))); |
| 82 | semaphore_->Signal(); |
| 83 | } |
| 84 | } |
| 85 | |
| 86 | private: |
| 87 | Semaphore* const semaphore_; |
| 88 | }; |
| 89 | |
| 90 | } // namespace |
| 91 | |
| 92 | |
| 93 | TEST(Semaphore, ProducerConsumer) { |
| 94 | char buffer[kBufferSize]; |
| 95 | std::memset(buffer, 0, sizeof(buffer)); |
| 96 | Semaphore free_space(kBufferSize); |
| 97 | Semaphore used_space(0); |
| 98 | ProducerThread producer_thread(buffer, &free_space, &used_space); |
| 99 | ConsumerThread consumer_thread(buffer, &free_space, &used_space); |
| 100 | producer_thread.Start(); |
| 101 | consumer_thread.Start(); |
| 102 | producer_thread.Join(); |
| 103 | consumer_thread.Join(); |
| 104 | } |
| 105 | |
| 106 | |
| 107 | TEST(Semaphore, WaitAndSignal) { |
| 108 | Semaphore semaphore(0); |
| 109 | WaitAndSignalThread t1(&semaphore); |
| 110 | WaitAndSignalThread t2(&semaphore); |
| 111 | |
| 112 | t1.Start(); |
| 113 | t2.Start(); |
| 114 | |
| 115 | // Make something available. |
| 116 | semaphore.Signal(); |
| 117 | |
| 118 | t1.Join(); |
| 119 | t2.Join(); |
| 120 | |
| 121 | semaphore.Wait(); |
| 122 | |
| 123 | EXPECT_FALSE(semaphore.WaitFor(TimeDelta::FromMicroseconds(1))); |
| 124 | } |
| 125 | |
| 126 | |
| 127 | TEST(Semaphore, WaitFor) { |
| 128 | Semaphore semaphore(0); |
| 129 | |
| 130 | // Semaphore not signalled - timeout. |
| 131 | ASSERT_FALSE(semaphore.WaitFor(TimeDelta::FromMicroseconds(0))); |
| 132 | ASSERT_FALSE(semaphore.WaitFor(TimeDelta::FromMicroseconds(100))); |
| 133 | ASSERT_FALSE(semaphore.WaitFor(TimeDelta::FromMicroseconds(1000))); |
| 134 | |
| 135 | // Semaphore signalled - no timeout. |
| 136 | semaphore.Signal(); |
| 137 | ASSERT_TRUE(semaphore.WaitFor(TimeDelta::FromMicroseconds(0))); |
| 138 | semaphore.Signal(); |
| 139 | ASSERT_TRUE(semaphore.WaitFor(TimeDelta::FromMicroseconds(100))); |
| 140 | semaphore.Signal(); |
| 141 | ASSERT_TRUE(semaphore.WaitFor(TimeDelta::FromMicroseconds(1000))); |
| 142 | } |
| 143 | |
| 144 | } // namespace base |
| 145 | } // namespace v8 |