Home | History | Annotate | Download | only in source 
      1 /*
      2  *  Copyright (c) 2012 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 "webrtc/system_wrappers/include/condition_variable_wrapper.h"
     12 
     13 #include "testing/gtest/include/gtest/gtest.h"
     14 #include "webrtc/base/platform_thread.h"
     15 #include "webrtc/base/scoped_ptr.h"
     16 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
     17 #include "webrtc/system_wrappers/include/tick_util.h"
     18 #include "webrtc/system_wrappers/include/trace.h"
     19 
     20 namespace webrtc {
     21 
     22 namespace {
     23 
     24 const int kLongWaitMs = 100 * 1000; // A long time in testing terms
     25 const int kShortWaitMs = 2 * 1000; // Long enough for process switches to happen
     26 const int kVeryShortWaitMs = 20; // Used when we want a timeout
     27 
     28 // A Baton is one possible control structure one can build using
     29 // conditional variables.
     30 // A Baton is always held by one and only one active thread - unlike
     31 // a lock, it can never be free.
     32 // One can pass it or grab it - both calls have timeouts.
     33 // Note - a production tool would guard against passing it without
     34 // grabbing it first. This one is for testing, so it doesn't.
     35 class Baton {
     36  public:
     37   Baton()
     38     : giver_sect_(CriticalSectionWrapper::CreateCriticalSection()),
     39       crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
     40       cond_var_(ConditionVariableWrapper::CreateConditionVariable()),
     41       being_passed_(false),
     42       pass_count_(0) {
     43   }
     44 
     45   ~Baton() {
     46     delete giver_sect_;
     47     delete crit_sect_;
     48     delete cond_var_;
     49   }
     50 
     51   // Pass the baton. Returns false if baton is not picked up in |max_msecs|.
     52   // Only one process can pass at the same time; this property is
     53   // ensured by the |giver_sect_| lock.
     54   bool Pass(uint32_t max_msecs) {
     55     CriticalSectionScoped cs_giver(giver_sect_);
     56     CriticalSectionScoped cs(crit_sect_);
     57     SignalBatonAvailable();
     58     const bool result = TakeBatonIfStillFree(max_msecs);
     59     if (result) {
     60       ++pass_count_;
     61     }
     62     return result;
     63   }
     64 
     65   // Grab the baton. Returns false if baton is not passed.
     66   bool Grab(uint32_t max_msecs) {
     67     CriticalSectionScoped cs(crit_sect_);
     68     return WaitUntilBatonOffered(max_msecs);
     69   }
     70 
     71   int PassCount() {
     72     // We don't allow polling PassCount() during a Pass()-call since there is
     73     // no guarantee that |pass_count_| is incremented until the Pass()-call
     74     // finishes. I.e. the Grab()-call may finish before |pass_count_| has been
     75     // incremented.
     76     // Thus, this function waits on giver_sect_.
     77     CriticalSectionScoped cs(giver_sect_);
     78     return pass_count_;
     79   }
     80 
     81  private:
     82   // Wait/Signal forms a classical semaphore on |being_passed_|.
     83   // These functions must be called with crit_sect_ held.
     84   bool WaitUntilBatonOffered(int timeout_ms) {
     85     while (!being_passed_) {
     86       if (!cond_var_->SleepCS(*crit_sect_, timeout_ms)) {
     87         return false;
     88       }
     89     }
     90     being_passed_ = false;
     91     cond_var_->Wake();
     92     return true;
     93   }
     94 
     95   void SignalBatonAvailable() {
     96     assert(!being_passed_);
     97     being_passed_ = true;
     98     cond_var_->Wake();
     99   }
    100 
    101   // Timeout extension: Wait for a limited time for someone else to
    102   // take it, and take it if it's not taken.
    103   // Returns true if resource is taken by someone else, false
    104   // if it is taken back by the caller.
    105   // This function must be called with both |giver_sect_| and
    106   // |crit_sect_| held.
    107   bool TakeBatonIfStillFree(int timeout_ms) {
    108     bool not_timeout = true;
    109     while (being_passed_ && not_timeout) {
    110       not_timeout = cond_var_->SleepCS(*crit_sect_, timeout_ms);
    111       // If we're woken up while variable is still held, we may have
    112       // gotten a wakeup destined for a grabber thread.
    113       // This situation is not treated specially here.
    114     }
    115     if (!being_passed_) {
    116       return true;
    117     } else {
    118       assert(!not_timeout);
    119       being_passed_ = false;
    120       return false;
    121     }
    122   }
    123 
    124   // Lock that ensures that there is only one thread in the active
    125   // part of Pass() at a time.
    126   // |giver_sect_| must always be acquired before |cond_var_|.
    127   CriticalSectionWrapper* giver_sect_;
    128   // Lock that protects |being_passed_|.
    129   CriticalSectionWrapper* crit_sect_;
    130   ConditionVariableWrapper* cond_var_;
    131   bool being_passed_;
    132   // Statistics information: Number of successfull passes.
    133   int pass_count_;
    134 };
    135 
    136 // Function that waits on a Baton, and passes it right back.
    137 // We expect these calls never to time out.
    138 bool WaitingRunFunction(void* obj) {
    139   Baton* the_baton = static_cast<Baton*> (obj);
    140   EXPECT_TRUE(the_baton->Grab(kLongWaitMs));
    141   EXPECT_TRUE(the_baton->Pass(kLongWaitMs));
    142   return true;
    143 }
    144 
    145 class CondVarTest : public ::testing::Test {
    146  public:
    147   CondVarTest() : thread_(&WaitingRunFunction, &baton_, "CondVarTest") {}
    148 
    149   virtual void SetUp() {
    150     thread_.Start();
    151   }
    152 
    153   virtual void TearDown() {
    154     // We have to wake the thread in order to make it obey the stop order.
    155     // But we don't know if the thread has completed the run function, so
    156     // we don't know if it will exit before or after the Pass.
    157     // Thus, we need to pin it down inside its Run function (between Grab
    158     // and Pass).
    159     ASSERT_TRUE(baton_.Pass(kShortWaitMs));
    160     ASSERT_TRUE(baton_.Grab(kShortWaitMs));
    161     thread_.Stop();
    162   }
    163 
    164  protected:
    165   Baton baton_;
    166 
    167  private:
    168   rtc::PlatformThread thread_;
    169 };
    170 
    171 // The SetUp and TearDown functions use condition variables.
    172 // This test verifies those pieces in isolation.
    173 // Disabled due to flakiness.  See bug 4262 for details.
    174 TEST_F(CondVarTest, DISABLED_InitFunctionsWork) {
    175   // All relevant asserts are in the SetUp and TearDown functions.
    176 }
    177 
    178 // This test verifies that one can use the baton multiple times.
    179 TEST_F(CondVarTest, DISABLED_PassBatonMultipleTimes) {
    180   const int kNumberOfRounds = 2;
    181   for (int i = 0; i < kNumberOfRounds; ++i) {
    182     ASSERT_TRUE(baton_.Pass(kShortWaitMs));
    183     ASSERT_TRUE(baton_.Grab(kShortWaitMs));
    184   }
    185   EXPECT_EQ(2 * kNumberOfRounds, baton_.PassCount());
    186 }
    187 
    188 TEST(CondVarWaitTest, WaitingWaits) {
    189   rtc::scoped_ptr<CriticalSectionWrapper> crit_sect(
    190       CriticalSectionWrapper::CreateCriticalSection());
    191   rtc::scoped_ptr<ConditionVariableWrapper> cond_var(
    192       ConditionVariableWrapper::CreateConditionVariable());
    193   CriticalSectionScoped cs(crit_sect.get());
    194   int64_t start_ms = TickTime::MillisecondTimestamp();
    195   EXPECT_FALSE(cond_var->SleepCS(*(crit_sect), kVeryShortWaitMs));
    196   int64_t end_ms = TickTime::MillisecondTimestamp();
    197   EXPECT_LE(start_ms + kVeryShortWaitMs, end_ms)
    198       << "actual elapsed:" << end_ms - start_ms;
    199 }
    200 
    201 }  // anonymous namespace
    202 
    203 }  // namespace webrtc
    204