--- /dev/null
+/*
+ * Copyright 2016 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+namespace folly {
+namespace fibers {
+
+//
+// TimedMutex implementation
+//
+
+template <typename BatonType>
+void TimedMutex<BatonType>::lock() {
+ pthread_spin_lock(&lock_);
+ if (!locked_) {
+ locked_ = true;
+ pthread_spin_unlock(&lock_);
+ return;
+ }
+
+ // Delay constructing the waiter until it is actually required.
+ // This makes a huge difference, at least in the benchmarks,
+ // when the mutex isn't locked.
+ MutexWaiter waiter;
+ waiters_.push_back(waiter);
+ pthread_spin_unlock(&lock_);
+ waiter.baton.wait();
+}
+
+template <typename BatonType>
+template <typename Rep, typename Period>
+bool TimedMutex<BatonType>::timed_lock(
+ const std::chrono::duration<Rep, Period>& duration) {
+ pthread_spin_lock(&lock_);
+ if (!locked_) {
+ locked_ = true;
+ pthread_spin_unlock(&lock_);
+ return true;
+ }
+
+ MutexWaiter waiter;
+ waiters_.push_back(waiter);
+ pthread_spin_unlock(&lock_);
+
+ if (!waiter.baton.timed_wait(duration)) {
+ // We timed out. Two cases:
+ // 1. We're still in the waiter list and we truly timed out
+ // 2. We're not in the waiter list anymore. This could happen if the baton
+ // times out but the mutex is unlocked before we reach this code. In this
+ // case we'll pretend we got the lock on time.
+ pthread_spin_lock(&lock_);
+ if (waiter.hook.is_linked()) {
+ waiters_.erase(waiters_.iterator_to(waiter));
+ pthread_spin_unlock(&lock_);
+ return false;
+ }
+ pthread_spin_unlock(&lock_);
+ }
+ return true;
+}
+
+template <typename BatonType>
+bool TimedMutex<BatonType>::try_lock() {
+ pthread_spin_lock(&lock_);
+ if (locked_) {
+ pthread_spin_unlock(&lock_);
+ return false;
+ }
+ locked_ = true;
+ pthread_spin_unlock(&lock_);
+ return true;
+}
+
+template <typename BatonType>
+void TimedMutex<BatonType>::unlock() {
+ pthread_spin_lock(&lock_);
+ if (waiters_.empty()) {
+ locked_ = false;
+ pthread_spin_unlock(&lock_);
+ return;
+ }
+ MutexWaiter& to_wake = waiters_.front();
+ waiters_.pop_front();
+ to_wake.baton.post();
+ pthread_spin_unlock(&lock_);
+}
+
+//
+// TimedRWMutex implementation
+//
+
+template <typename BatonType>
+void TimedRWMutex<BatonType>::read_lock() {
+ pthread_spin_lock(&lock_);
+ if (state_ == State::WRITE_LOCKED) {
+ MutexWaiter waiter;
+ read_waiters_.push_back(waiter);
+ pthread_spin_unlock(&lock_);
+ waiter.baton.wait();
+ assert(state_ == State::READ_LOCKED);
+ return;
+ }
+ assert(
+ (state_ == State::UNLOCKED && readers_ == 0) ||
+ (state_ == State::READ_LOCKED && readers_ > 0));
+ assert(read_waiters_.empty());
+ state_ = State::READ_LOCKED;
+ readers_ += 1;
+ pthread_spin_unlock(&lock_);
+}
+
+template <typename BatonType>
+template <typename Rep, typename Period>
+bool TimedRWMutex<BatonType>::timed_read_lock(
+ const std::chrono::duration<Rep, Period>& duration) {
+ pthread_spin_lock(&lock_);
+ if (state_ == State::WRITE_LOCKED) {
+ MutexWaiter waiter;
+ read_waiters_.push_back(waiter);
+ pthread_spin_unlock(&lock_);
+
+ if (!waiter.baton.timed_wait(duration)) {
+ // We timed out. Two cases:
+ // 1. We're still in the waiter list and we truly timed out
+ // 2. We're not in the waiter list anymore. This could happen if the baton
+ // times out but the mutex is unlocked before we reach this code. In
+ // this case we'll pretend we got the lock on time.
+ pthread_spin_lock(&lock_);
+ if (waiter.hook.is_linked()) {
+ read_waiters_.erase(read_waiters_.iterator_to(waiter));
+ pthread_spin_unlock(&lock_);
+ return false;
+ }
+ pthread_spin_unlock(&lock_);
+ }
+ return true;
+ }
+ assert(
+ (state_ == State::UNLOCKED && readers_ == 0) ||
+ (state_ == State::READ_LOCKED && readers_ > 0));
+ assert(read_waiters_.empty());
+ state_ = State::READ_LOCKED;
+ readers_ += 1;
+ pthread_spin_unlock(&lock_);
+ return true;
+}
+
+template <typename BatonType>
+bool TimedRWMutex<BatonType>::try_read_lock() {
+ pthread_spin_lock(&lock_);
+ if (state_ != State::WRITE_LOCKED) {
+ assert(
+ (state_ == State::UNLOCKED && readers_ == 0) ||
+ (state_ == State::READ_LOCKED && readers_ > 0));
+ assert(read_waiters_.empty());
+ state_ = State::READ_LOCKED;
+ readers_ += 1;
+ pthread_spin_unlock(&lock_);
+ return true;
+ }
+ pthread_spin_unlock(&lock_);
+ return false;
+}
+
+template <typename BatonType>
+void TimedRWMutex<BatonType>::write_lock() {
+ pthread_spin_lock(&lock_);
+ if (state_ == State::UNLOCKED) {
+ verify_unlocked_properties();
+ state_ = State::WRITE_LOCKED;
+ pthread_spin_unlock(&lock_);
+ return;
+ }
+ MutexWaiter waiter;
+ write_waiters_.push_back(waiter);
+ pthread_spin_unlock(&lock_);
+ waiter.baton.wait();
+}
+
+template <typename BatonType>
+template <typename Rep, typename Period>
+bool TimedRWMutex<BatonType>::timed_write_lock(
+ const std::chrono::duration<Rep, Period>& duration) {
+ pthread_spin_lock(&lock_);
+ if (state_ == State::UNLOCKED) {
+ verify_unlocked_properties();
+ state_ = State::WRITE_LOCKED;
+ pthread_spin_unlock(&lock_);
+ return true;
+ }
+ MutexWaiter waiter;
+ write_waiters_.push_back(waiter);
+ pthread_spin_unlock(&lock_);
+
+ if (!waiter.baton.timed_wait(duration)) {
+ // We timed out. Two cases:
+ // 1. We're still in the waiter list and we truly timed out
+ // 2. We're not in the waiter list anymore. This could happen if the baton
+ // times out but the mutex is unlocked before we reach this code. In
+ // this case we'll pretend we got the lock on time.
+ pthread_spin_lock(&lock_);
+ if (waiter.hook.is_linked()) {
+ write_waiters_.erase(write_waiters_.iterator_to(waiter));
+ pthread_spin_unlock(&lock_);
+ return false;
+ }
+ pthread_spin_unlock(&lock_);
+ }
+ assert(state_ == State::WRITE_LOCKED);
+ return true;
+}
+
+template <typename BatonType>
+bool TimedRWMutex<BatonType>::try_write_lock() {
+ pthread_spin_lock(&lock_);
+ if (state_ == State::UNLOCKED) {
+ verify_unlocked_properties();
+ state_ = State::WRITE_LOCKED;
+ pthread_spin_unlock(&lock_);
+ return true;
+ }
+ pthread_spin_unlock(&lock_);
+ return false;
+}
+
+template <typename BatonType>
+void TimedRWMutex<BatonType>::unlock() {
+ pthread_spin_lock(&lock_);
+ assert(state_ != State::UNLOCKED);
+ assert(
+ (state_ == State::READ_LOCKED && readers_ > 0) ||
+ (state_ == State::WRITE_LOCKED && readers_ == 0));
+ if (state_ == State::READ_LOCKED) {
+ readers_ -= 1;
+ }
+
+ if (!read_waiters_.empty()) {
+ assert(
+ state_ == State::WRITE_LOCKED && readers_ == 0 &&
+ "read waiters can only accumulate while write locked");
+ state_ = State::READ_LOCKED;
+ readers_ = read_waiters_.size();
+
+ while (!read_waiters_.empty()) {
+ MutexWaiter& to_wake = read_waiters_.front();
+ read_waiters_.pop_front();
+ to_wake.baton.post();
+ }
+ } else if (readers_ == 0) {
+ if (!write_waiters_.empty()) {
+ assert(read_waiters_.empty());
+ state_ = State::WRITE_LOCKED;
+
+ // Wake a single writer (after releasing the spin lock)
+ MutexWaiter& to_wake = write_waiters_.front();
+ write_waiters_.pop_front();
+ to_wake.baton.post();
+ } else {
+ verify_unlocked_properties();
+ state_ = State::UNLOCKED;
+ }
+ } else {
+ assert(state_ == State::READ_LOCKED);
+ }
+ pthread_spin_unlock(&lock_);
+}
+
+template <typename BatonType>
+void TimedRWMutex<BatonType>::downgrade() {
+ pthread_spin_lock(&lock_);
+ assert(state_ == State::WRITE_LOCKED && readers_ == 0);
+ state_ = State::READ_LOCKED;
+ readers_ += 1;
+
+ if (!read_waiters_.empty()) {
+ readers_ += read_waiters_.size();
+
+ while (!read_waiters_.empty()) {
+ MutexWaiter& to_wake = read_waiters_.front();
+ read_waiters_.pop_front();
+ to_wake.baton.post();
+ }
+ }
+ pthread_spin_unlock(&lock_);
+}
+}
+}
projects / folly.git / blobdiff