V8 Project
semaphore-unittest.cc
Go to the documentation of this file.
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 
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
ProducerThread(char *buffer, Semaphore *free_space, Semaphore *used_space)
ConsumerThread(const char *buffer, Semaphore *free_space, Semaphore *used_space)
#define OVERRIDE
TEST(CPUTest, FeatureImplications)
Definition: cpu-unittest.cc:11
Debugger support for the V8 JavaScript engine.
Definition: accessors.cc:20