futex-emulation.cc 7.08 KB
Newer Older
binji's avatar
binji committed
1 2 3 4 5 6 7 8 9 10 11 12 13
// Copyright 2015 the V8 project 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 "src/futex-emulation.h"

#include <limits>

#include "src/base/macros.h"
#include "src/base/platform/time.h"
#include "src/conversions.h"
#include "src/handles-inl.h"
#include "src/isolate.h"
14
#include "src/objects-inl.h"
binji's avatar
binji committed
15 16 17 18 19 20 21 22 23

namespace v8 {
namespace internal {

base::LazyMutex FutexEmulation::mutex_ = LAZY_MUTEX_INITIALIZER;
base::LazyInstance<FutexWaitList>::type FutexEmulation::wait_list_ =
    LAZY_INSTANCE_INITIALIZER;


24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
void FutexWaitListNode::NotifyWake() {
  // Lock the FutexEmulation mutex before notifying. We know that the mutex
  // will have been unlocked if we are currently waiting on the condition
  // variable.
  //
  // The mutex may also not be locked if the other thread is currently handling
  // interrupts, or if FutexEmulation::Wait was just called and the mutex
  // hasn't been locked yet. In either of those cases, we set the interrupted
  // flag to true, which will be tested after the mutex is re-locked.
  base::LockGuard<base::Mutex> lock_guard(FutexEmulation::mutex_.Pointer());
  if (waiting_) {
    cond_.NotifyOne();
    interrupted_ = true;
  }
}


binji's avatar
binji committed
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
FutexWaitList::FutexWaitList() : head_(nullptr), tail_(nullptr) {}


void FutexWaitList::AddNode(FutexWaitListNode* node) {
  DCHECK(node->prev_ == nullptr && node->next_ == nullptr);
  if (tail_) {
    tail_->next_ = node;
  } else {
    head_ = node;
  }

  node->prev_ = tail_;
  node->next_ = nullptr;
  tail_ = node;
}


void FutexWaitList::RemoveNode(FutexWaitListNode* node) {
  if (node->prev_) {
    node->prev_->next_ = node->next_;
  } else {
    head_ = node->next_;
  }

  if (node->next_) {
    node->next_->prev_ = node->prev_;
  } else {
    tail_ = node->prev_;
  }

  node->prev_ = node->next_ = nullptr;
}


Object* FutexEmulation::Wait(Isolate* isolate,
                             Handle<JSArrayBuffer> array_buffer, size_t addr,
                             int32_t value, double rel_timeout_ms) {
78
  DCHECK(addr < NumberToSize(array_buffer->byte_length()));
binji's avatar
binji committed
79 80 81 82 83 84 85 86

  void* backing_store = array_buffer->backing_store();
  int32_t* p =
      reinterpret_cast<int32_t*>(static_cast<int8_t*>(backing_store) + addr);

  base::LockGuard<base::Mutex> lock_guard(mutex_.Pointer());

  if (*p != value) {
87
    return isolate->heap()->not_equal();
binji's avatar
binji committed
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
  }

  FutexWaitListNode* node = isolate->futex_wait_list_node();

  node->backing_store_ = backing_store;
  node->wait_addr_ = addr;
  node->waiting_ = true;

  bool use_timeout = rel_timeout_ms != V8_INFINITY;

  base::TimeDelta rel_timeout;
  if (use_timeout) {
    // Convert to nanoseconds.
    double rel_timeout_ns = rel_timeout_ms *
                            base::Time::kNanosecondsPerMicrosecond *
                            base::Time::kMicrosecondsPerMillisecond;
    if (rel_timeout_ns >
        static_cast<double>(std::numeric_limits<int64_t>::max())) {
      // 2**63 nanoseconds is 292 years. Let's just treat anything greater as
      // infinite.
      use_timeout = false;
    } else {
      rel_timeout = base::TimeDelta::FromNanoseconds(
          static_cast<int64_t>(rel_timeout_ns));
    }
  }

115 116
  base::TimeTicks start_time = base::TimeTicks::Now();
  base::TimeTicks timeout_time = start_time + rel_timeout;
117
  base::TimeTicks current_time = start_time;
binji's avatar
binji committed
118 119 120 121 122 123

  wait_list_.Pointer()->AddNode(node);

  Object* result;

  while (true) {
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
    bool interrupted = node->interrupted_;
    node->interrupted_ = false;

    // Unlock the mutex here to prevent deadlock from lock ordering between
    // mutex_ and mutexes locked by HandleInterrupts.
    mutex_.Pointer()->Unlock();

    // Because the mutex is unlocked, we have to be careful about not dropping
    // an interrupt. The notification can happen in three different places:
    // 1) Before Wait is called: the notification will be dropped, but
    //    interrupted_ will be set to 1. This will be checked below.
    // 2) After interrupted has been checked here, but before mutex_ is
    //    acquired: interrupted is checked again below, with mutex_ locked.
    //    Because the wakeup signal also acquires mutex_, we know it will not
    //    be able to notify until mutex_ is released below, when waiting on the
    //    condition variable.
    // 3) After the mutex is released in the call to WaitFor(): this
    // notification will wake up the condition variable. node->waiting() will
    // be false, so we'll loop and then check interrupts.
    if (interrupted) {
      Object* interrupt_object = isolate->stack_guard()->HandleInterrupts();
145
      if (interrupt_object->IsException(isolate)) {
146 147 148 149
        result = interrupt_object;
        mutex_.Pointer()->Lock();
        break;
      }
150 151
    }

152
    mutex_.Pointer()->Lock();
binji's avatar
binji committed
153

154
    if (node->interrupted_) {
155
      // An interrupt occurred while the mutex_ was unlocked. Don't wait yet.
156 157
      continue;
    }
binji's avatar
binji committed
158 159

    if (!node->waiting_) {
160
      result = isolate->heap()->ok();
binji's avatar
binji committed
161 162 163
      break;
    }

164 165 166 167
    // No interrupts, now wait.
    if (use_timeout) {
      current_time = base::TimeTicks::Now();
      if (current_time >= timeout_time) {
168
        result = isolate->heap()->timed_out();
169 170 171 172
        break;
      }

      base::TimeDelta time_until_timeout = timeout_time - current_time;
173
      DCHECK_GE(time_until_timeout.InMicroseconds(), 0);
174 175 176 177 178
      bool wait_for_result =
          node->cond_.WaitFor(mutex_.Pointer(), time_until_timeout);
      USE(wait_for_result);
    } else {
      node->cond_.Wait(mutex_.Pointer());
binji's avatar
binji committed
179
    }
180 181

    // Spurious wakeup, interrupt or timeout.
binji's avatar
binji committed
182 183 184
  }

  wait_list_.Pointer()->RemoveNode(node);
185
  node->waiting_ = false;
binji's avatar
binji committed
186 187 188 189 190 191

  return result;
}

Object* FutexEmulation::Wake(Isolate* isolate,
                             Handle<JSArrayBuffer> array_buffer, size_t addr,
192
                             uint32_t num_waiters_to_wake) {
193
  DCHECK(addr < NumberToSize(array_buffer->byte_length()));
binji's avatar
binji committed
194 195 196 197 198 199 200 201 202 203

  int waiters_woken = 0;
  void* backing_store = array_buffer->backing_store();

  base::LockGuard<base::Mutex> lock_guard(mutex_.Pointer());
  FutexWaitListNode* node = wait_list_.Pointer()->head_;
  while (node && num_waiters_to_wake > 0) {
    if (backing_store == node->backing_store_ && addr == node->wait_addr_) {
      node->waiting_ = false;
      node->cond_.NotifyOne();
204 205 206
      if (num_waiters_to_wake != kWakeAll) {
        --num_waiters_to_wake;
      }
binji's avatar
binji committed
207 208 209 210 211 212 213 214 215 216 217 218 219
      waiters_woken++;
    }

    node = node->next_;
  }

  return Smi::FromInt(waiters_woken);
}


Object* FutexEmulation::NumWaitersForTesting(Isolate* isolate,
                                             Handle<JSArrayBuffer> array_buffer,
                                             size_t addr) {
220
  DCHECK(addr < NumberToSize(array_buffer->byte_length()));
binji's avatar
binji committed
221 222 223 224 225 226 227
  void* backing_store = array_buffer->backing_store();

  base::LockGuard<base::Mutex> lock_guard(mutex_.Pointer());

  int waiters = 0;
  FutexWaitListNode* node = wait_list_.Pointer()->head_;
  while (node) {
228 229
    if (backing_store == node->backing_store_ && addr == node->wait_addr_ &&
        node->waiting_) {
binji's avatar
binji committed
230 231 232 233 234 235 236 237 238 239 240
      waiters++;
    }

    node = node->next_;
  }

  return Smi::FromInt(waiters);
}

}  // namespace internal
}  // namespace v8