Home | History | Annotate | Download | only in system 
      1 // Copyright 2013 The Chromium 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 "mojo/system/waiter.h"
      6 
      7 #include <limits>
      8 
      9 #include "base/logging.h"
     10 #include "base/time/time.h"
     11 
     12 namespace mojo {
     13 namespace system {
     14 
     15 Waiter::Waiter()
     16     : cv_(&lock_),
     17 #ifndef NDEBUG
     18       initialized_(false),
     19 #endif
     20       awoken_(false),
     21       awake_result_(MOJO_RESULT_INTERNAL),
     22       awake_context_(static_cast<uint32_t>(-1)) {
     23 }
     24 
     25 Waiter::~Waiter() {
     26 }
     27 
     28 void Waiter::Init() {
     29 #ifndef NDEBUG
     30   initialized_ = true;
     31 #endif
     32   awoken_ = false;
     33   // NOTE(vtl): If performance ever becomes an issue, we can disable the setting
     34   // of |awake_result_| (except the first one in |Awake()|) in Release builds.
     35   awake_result_ = MOJO_RESULT_INTERNAL;
     36 }
     37 
     38 // TODO(vtl): Fast-path the |deadline == 0| case?
     39 MojoResult Waiter::Wait(MojoDeadline deadline, uint32_t* context) {
     40   base::AutoLock locker(lock_);
     41 
     42 #ifndef NDEBUG
     43   DCHECK(initialized_);
     44   // It'll need to be re-initialized after this.
     45   initialized_ = false;
     46 #endif
     47 
     48   // Fast-path the already-awoken case:
     49   if (awoken_) {
     50     DCHECK_NE(awake_result_, MOJO_RESULT_INTERNAL);
     51     if (context)
     52       *context = awake_context_;
     53     return awake_result_;
     54   }
     55 
     56   // |MojoDeadline| is actually a |uint64_t|, but we need a signed quantity.
     57   // Treat any out-of-range deadline as "forever" (which is wrong, but okay
     58   // since 2^63 microseconds is ~300000 years). Note that this also takes care
     59   // of the |MOJO_DEADLINE_INDEFINITE| (= 2^64 - 1) case.
     60   if (deadline > static_cast<uint64_t>(std::numeric_limits<int64_t>::max())) {
     61     do {
     62       cv_.Wait();
     63     } while (!awoken_);
     64   } else {
     65     // NOTE(vtl): This is very inefficient on POSIX, since pthreads condition
     66     // variables take an absolute deadline.
     67     const base::TimeTicks end_time = base::TimeTicks::HighResNow() +
     68         base::TimeDelta::FromMicroseconds(static_cast<int64_t>(deadline));
     69     do {
     70       base::TimeTicks now_time = base::TimeTicks::HighResNow();
     71       if (now_time >= end_time)
     72         return MOJO_RESULT_DEADLINE_EXCEEDED;
     73 
     74       cv_.TimedWait(end_time - now_time);
     75     } while (!awoken_);
     76   }
     77 
     78   DCHECK_NE(awake_result_, MOJO_RESULT_INTERNAL);
     79   if (context)
     80     *context = awake_context_;
     81   return awake_result_;
     82 }
     83 
     84 void Waiter::Awake(MojoResult result, uint32_t context) {
     85   base::AutoLock locker(lock_);
     86 
     87   if (awoken_)
     88     return;
     89 
     90   awoken_ = true;
     91   awake_result_ = result;
     92   awake_context_ = context;
     93   cv_.Signal();
     94   // |cv_.Wait()|/|cv_.TimedWait()| will return after |lock_| is released.
     95 }
     96 
     97 }  // namespace system
     98 }  // namespace mojo
     99