[libc-commits] [libc] [libc] add rwlock (PR #94156)

[via libc-commits]

================
@@ -0,0 +1,525 @@
+//===--- Implementation of a Linux RwLock class ---------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_LIBC_SRC_SUPPORT_THREADS_LINUX_RWLOCK_H
+#define LLVM_LIBC_SRC_SUPPORT_THREADS_LINUX_RWLOCK_H
+
+#include "hdr/errno_macros.h"
+#include "hdr/types/pid_t.h"
+#include "src/__support/CPP/atomic.h"
+#include "src/__support/CPP/optional.h"
+#include "src/__support/OSUtil/syscall.h"
+#include "src/__support/common.h"
+#include "src/__support/libc_assert.h"
+#include "src/__support/macros/attributes.h"
+#include "src/__support/macros/optimization.h"
+#include "src/__support/threads/linux/futex_utils.h"
+#include "src/__support/threads/linux/futex_word.h"
+#include "src/__support/threads/linux/raw_mutex.h"
+#include "src/__support/threads/sleep.h"
+
+#ifndef LIBC_COPT_RWLOCK_DEFAULT_SPIN_COUNT
+#define LIBC_COPT_RWLOCK_DEFAULT_SPIN_COUNT 100
+#endif
+
+#ifndef LIBC_COPT_TIMEOUT_ENSURE_MONOTONICITY
+#define LIBC_COPT_TIMEOUT_ENSURE_MONOTONICITY 1
+#warning "LIBC_COPT_TIMEOUT_ENSURE_MONOTONICITY is not defined, defaulting to 1"
+#endif
+
+#if LIBC_COPT_TIMEOUT_ENSURE_MONOTONICITY
+#include "src/__support/time/linux/monotonicity.h"
+#endif
+
+namespace LIBC_NAMESPACE {
+class RwLock {
+public:
+  enum class Role : char { Reader, Writer };
+
+private:
+  class WaitingQueue final : private RawMutex {
+    FutexWordType pending_reader;
+    FutexWordType pending_writer;
+    Futex reader_serialization;
+    Futex writer_serialization;
+
+  public:
+    class Guard {
+      WaitingQueue &queue;
+
+      LIBC_INLINE constexpr Guard(WaitingQueue &queue) : queue(queue) {}
+
+    public:
+      LIBC_INLINE ~Guard() { queue.unlock(); }
+      template <Role role> LIBC_INLINE FutexWordType &pending_count() {
+        if constexpr (role == Role::Reader)
+          return queue.pending_reader;
+        else
+          return queue.pending_writer;
+      }
+      template <Role role> LIBC_INLINE FutexWordType &serialization() {
+        if constexpr (role == Role::Reader)
+          return queue.reader_serialization.val;
+        else
+          return queue.writer_serialization.val;
+      }
+      friend WaitingQueue;
+    };
+
+  public:
+    LIBC_INLINE constexpr WaitingQueue()
+        : RawMutex(), pending_reader(0), pending_writer(0),
+          reader_serialization(0), writer_serialization(0) {}
+    LIBC_INLINE Guard acquire() {
+      this->lock();
+      return Guard(*this);
+    }
+
+    template <Role role>
+    LIBC_INLINE long wait(FutexWordType expected,
+                          cpp::optional<Futex::Timeout> timeout,
+                          bool is_pshared) {
+      if constexpr (role == Role::Reader)
+        return reader_serialization.wait(expected, timeout, is_pshared);
+      else
+        return writer_serialization.wait(expected, timeout, is_pshared);
+    }
+
+    template <Role role> LIBC_INLINE long notify(bool is_pshared) {
+      if constexpr (role == Role::Reader)
+        return reader_serialization.notify_all(is_pshared);
+      else
+        return writer_serialization.notify_one(is_pshared);
+    }
+  };
+
+public:
+  enum class LockResult : int {
+    Success = 0,
+    TimedOut = ETIMEDOUT,
+    Overflow = EAGAIN,
+    Busy = EBUSY,
+    Deadlock = EDEADLOCK,
+    PermissionDenied = EPERM,
+  };
+
+private:
+  // The State of the RwLock is stored in a 32-bit word, consisting of the
+  // following components:
+  // -----------------------------------------------
+  // | Range |           Description               |
+  // ===============================================
+  // | 0     | Pending Reader Bit                  |
+  // -----------------------------------------------
+  // | 1     | Pending Writer Bit                  |
+  // -----------------------------------------------
+  // | 2-30  | Active Reader Count                 |
+  // -----------------------------------------------
+  // | 31    | Active Writer Bit                   |
+  // -----------------------------------------------
+  class State {
+    // We use the signed interger as the state type. It is easier
+    // to handle state trasitions and detections using signed integers.
+    using Type = int32_t;
+
+    // Shift amounts to access the components of the state.
+    LIBC_INLINE_VAR static constexpr Type PENDING_READER_SHIFT = 0;
+    LIBC_INLINE_VAR static constexpr Type PENDING_WRITER_SHIFT = 1;
+    LIBC_INLINE_VAR static constexpr Type ACTIVE_READER_SHIFT = 2;
+    LIBC_INLINE_VAR static constexpr Type ACTIVE_WRITER_SHIFT = 31;
+
+    // Bitmasks to access the components of the state.
+    LIBC_INLINE_VAR static constexpr Type PENDING_READER_BIT =
+        1 << PENDING_READER_SHIFT;
+    LIBC_INLINE_VAR static constexpr Type PENDING_WRITER_BIT =
+        1 << PENDING_WRITER_SHIFT;
+    LIBC_INLINE_VAR static constexpr Type ACTIVE_READER_COUNT_UNIT =
+        1 << ACTIVE_READER_SHIFT;
+    LIBC_INLINE_VAR static constexpr Type ACTIVE_WRITER_BIT =
+        1 << ACTIVE_WRITER_SHIFT;
+    LIBC_INLINE_VAR static constexpr Type PENDING_MASK =
+        PENDING_READER_BIT | PENDING_WRITER_BIT;
+
+  private:
+    Type state;
+
+  public:
+    // Construction and conversion functions.
+    LIBC_INLINE constexpr State(Type state = 0) : state(state) {}
+    LIBC_INLINE constexpr operator Type() const { return state; }
+
+    // Utilities to check the state of the RwLock.
+    LIBC_INLINE constexpr bool has_active_writer() const { return state < 0; }
+    LIBC_INLINE constexpr bool has_active_reader() const {
+      return state > ACTIVE_READER_COUNT_UNIT;
+    }
+    LIBC_INLINE constexpr bool has_acitve_owner() const {
+      return has_active_reader() || has_active_writer();
+    }
+    LIBC_INLINE constexpr bool has_last_reader() const {
+      return (state >> ACTIVE_READER_SHIFT) == 1;
+    }
+    LIBC_INLINE constexpr bool has_pending_writer() const {
+      return state & PENDING_WRITER_BIT;
+    }
+    LIBC_INLINE constexpr bool has_pending() const {
+      return state & PENDING_MASK;
+    }
+    LIBC_INLINE constexpr State set_writer_bit() const {
+      return State(state | ACTIVE_WRITER_BIT);
+    }
+
+    // The preference parameter changes the behavior of the lock acquisition
+    // if there are both readers and writers waiting for the lock. If writers
+    // are preferred, reader acquisition will be blocked until all pending
+    // writers are served.
+    template <Role role> LIBC_INLINE bool can_acquire(Role preference) const {
+      if constexpr (role == Role::Reader) {
+        switch (preference) {
+        case Role::Reader:
+          return !has_active_writer();
+        case Role::Writer:
+          return !has_active_writer() && !has_pending_writer();
+        }
+      } else
+        return !has_acitve_owner();
+    }
+
+    // This function check if it is possible to grow the reader count without
+    // overflowing the state.
+    LIBC_INLINE cpp::optional<State> try_increase_reader_count() const {
+      LIBC_ASSERT(!has_active_writer() &&
+                  "try_increase_reader_count shall only be called when there "
+                  "is no active writer.");
+      State res;
+      if (LIBC_UNLIKELY(__builtin_sadd_overflow(state, ACTIVE_READER_COUNT_UNIT,
+                                                &res.state)))
+        return cpp::nullopt;
+      return res;
+    }
+
+    // Utilities to do atomic operations on the state.
+    LIBC_INLINE static State
+    fetch_sub_reader_count(cpp::Atomic<Type> &target,
+                           cpp::MemoryOrder order = cpp::MemoryOrder::SEQ_CST) {
----------------
QuarticCat wrote:

Looks like none of these `order` defaults are used. I was wondering why `SEQ_CST` is required then find that no caller really use it.

https://github.com/llvm/llvm-project/pull/94156