condition_variable

Go to the documentation of this file.

/*
 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
 * Copyright (c) 2016-2025 Liviu Ionescu. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software
 * for any purpose is hereby granted, under the terms of the MIT license.
 *
 * If a copy of the license was not distributed with this file, it can
 * be obtained from https://opensource.org/licenses/mit.
 */
 
/*
 * The code is inspired by LLVM libcxx and GNU libstdc++-v3.
 */
 
#ifndef CMSIS_PLUS_ESTD_CONDITION_VARIABLE_
#define CMSIS_PLUS_ESTD_CONDITION_VARIABLE_
 
// ----------------------------------------------------------------------------
 
// Include the next <condition_variable> file found in the search path.
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wgnu-include-next"
#endif
#include_next <condition_variable>
#pragma GCC diagnostic pop
 
#include <memory>
#include <chrono>
 
#include <cmsis-plus/estd/mutex>
 
// ----------------------------------------------------------------------------
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#endif
 
// ----------------------------------------------------------------------------
 
namespace os
{
  namespace estd
  {
 
    // ========================================================================
    enum class cv_status
    {
      no_timeout, //
      timeout
    };
 
    class condition_variable
    {
    private:
      using native_type = os::rtos::condition_variable;
 
    public:
      using native_handle_type = native_type*;
 
      condition_variable ();
 
      ~condition_variable ();
 
      condition_variable (const condition_variable&) = delete;
      condition_variable&
      operator= (const condition_variable&)
          = delete;
 
      void
      notify_one () noexcept;
 
      void
      notify_all () noexcept;
 
      void
      wait (std::unique_lock<mutex>& lock);
 
      template <class Predicate_T>
      void
      wait (std::unique_lock<mutex>& lock, Predicate_T pred);
 
      template <class Clock_T, class Duration_T>
      cv_status
      wait_until (
          std::unique_lock<mutex>& lock,
          const std::chrono::time_point<Clock_T, Duration_T>& abs_time);
 
      template <class Clock_T, class Duration_T, class Predicate_T>
      bool
      wait_until (std::unique_lock<mutex>& lock,
                  const std::chrono::time_point<Clock_T, Duration_T>& abs_time,
                  Predicate_T pred);
 
      template <class Rep_T, class Period_T>
      cv_status
      wait_for (std::unique_lock<mutex>& lock,
                const std::chrono::duration<Rep_T, Period_T>& rel_time);
 
      template <class Rep_T, class Period_T, class Predicate_T>
      bool
      wait_for (std::unique_lock<mutex>& lock,
                const std::chrono::duration<Rep_T, Period_T>& rel_time,
                Predicate_T pred);
 
      native_handle_type
      native_handle ();
 
    protected:
      native_type ncv_;
      using Native_clock = os::estd::chrono::systick_clock;
    };
 
    void
    notify_all_at_thread_exit (condition_variable& cond,
                               std::unique_lock<mutex> lk);
 
    class condition_variable_any
    {
    public:
      condition_variable_any ();
 
      ~condition_variable_any ();
 
      condition_variable_any (const condition_variable_any&) = delete;
      condition_variable_any&
      operator= (const condition_variable_any&)
          = delete;
 
      void
      notify_one () noexcept;
 
      void
      notify_all () noexcept;
 
      template <class Lock_T>
      void
      wait (Lock_T& lock);
 
      template <class Lock_T, class Predicate_T>
      void
      wait (Lock_T& lock, Predicate_T pred);
 
      template <class Lock_T, class Clock_T, class Duration_T>
      cv_status
      wait_until (
          Lock_T& lock,
          const std::chrono::time_point<Clock_T, Duration_T>& abs_time);
 
      template <class Lock_T, class Clock_T, class Duration_T,
                class Predicate_T>
      bool
      wait_until (Lock_T& lock,
                  const std::chrono::time_point<Clock_T, Duration_T>& abs_time,
                  Predicate_T pred);
 
      template <class Lock_T, class Rep_T, class Period_T>
      cv_status
      wait_for (Lock_T& lock,
                const std::chrono::duration<Rep_T, Period_T>& rel_time);
 
      template <class Lock_T, class Rep_T, class Period_T, class Predicate_T>
      bool
      wait_for (Lock_T& lock,
                const std::chrono::duration<Rep_T, Period_T>& rel_time,
                Predicate_T pred);
 
    protected:
      condition_variable cv_;
      std::shared_ptr<mutex> mx_;
 
      using Native_clock = os::estd::chrono::systick_clock;
    };
 
    // ========================================================================
    // Inline & template implementations.
    // ========================================================================
    inline condition_variable::condition_variable ()
    {
    }
 
    inline condition_variable::~condition_variable ()
    {
    }
 
    template <class Predicate_T>
    void
    condition_variable::wait (std::unique_lock<mutex>& lock, Predicate_T pred)
    {
      while (!pred ())
        wait (lock);
    }
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
 
    template <class Clock_T, class Duration_T>
    cv_status
    condition_variable::wait_until (
        std::unique_lock<mutex>& lock,
        const std::chrono::time_point<Clock_T, Duration_T>& abs_time)
    {
      using namespace std::chrono;
      using clock = Clock_T;
 
#if 0
        wait_for (lock, abs_time - Clock_T::now ());
        return
        Clock_T::now () < abs_time ?
        cv_status::no_timeout : cv_status::timeout;
#else
      // Optimise to native (ticks). LLVM compares using the
      // original clock, which might be more accurate.
      Native_clock::duration rel_time
          = std::chrono::duration_cast<Native_clock::duration> (
              abs_time - clock::now ());
      return wait_for (lock, rel_time);
#endif
    }
 
#pragma GCC diagnostic pop
 
    template <class Clock_T, class Duration_T, class Predicate_T>
    bool
    condition_variable::wait_until (
        std::unique_lock<mutex>& lock,
        const std::chrono::time_point<Clock_T, Duration_T>& abs_time,
        Predicate_T pred)
    {
      while (!pred ())
        {
          if (wait_until (lock, abs_time) == cv_status::timeout)
            return pred ();
        }
      return true;
    }
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
 
    template <class Rep_T, class Period_T>
    cv_status
    condition_variable::wait_for (
        std::unique_lock<mutex>& lock,
        const std::chrono::duration<Rep_T, Period_T>& rel_time)
    {
      using namespace std::chrono;
 
      if (rel_time <= rel_time.zero ())
        {
          return cv_status::timeout;
        }
 
      Native_clock::time_point start_tp = Native_clock::now ();
 
      os::rtos::clock::duration_t ticks
          = os::estd::chrono::ceil<std::chrono::duration<
              os::rtos::clock::duration_t, typename Native_clock::period>> (
                rel_time)
                .count ();
 
      ncv_.timed_wait (
          /*(rtos::mutex &)*/ (*(lock.mutex ()->native_handle ())), ticks);
 
      return (Native_clock::now () - start_tp) < rel_time
                 ? cv_status::no_timeout
                 : cv_status::timeout;
    }
 
    template <class Rep_T, class Period_T, class Predicate_T>
    inline bool
    condition_variable::wait_for (
        std::unique_lock<mutex>& lock,
        const std::chrono::duration<Rep_T, Period_T>& rel_time,
        Predicate_T pred)
    {
      return wait_until (lock, Native_clock::now () + rel_time,
                         std::move (pred));
    }
 
#pragma GCC diagnostic pop
 
    // ========================================================================
 
    inline condition_variable_any::condition_variable_any ()
        : cv_{}, //
          mx_{ std::make_shared<mutex> () }
    {
    }
 
    inline condition_variable_any::~condition_variable_any ()
    {
    }
 
    inline void
    condition_variable_any::notify_one () noexcept
    {
      std::lock_guard<mutex> lock (*mx_);
      cv_.notify_one ();
    }
 
    inline void
    condition_variable_any::notify_all () noexcept
    {
      std::lock_guard<mutex> lock (*mx_);
      cv_.notify_all ();
    }
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wreserved-identifier"
#endif
    struct __lock_external
    {
      template <class Lock_T>
      void
      operator() (Lock_T* lk)
      {
        lk->lock ();
      }
    };
#pragma GCC diagnostic pop
 
    template <class Lock_T>
    void
    condition_variable_any::wait (Lock_T& lock)
    {
      std::shared_ptr<mutex> mx = mx_;
      std::unique_lock<mutex> lk (*mx);
      lock.unlock ();
      std::unique_ptr<Lock_T, __lock_external> lxx (&lock);
      std::lock_guard<std::unique_lock<mutex>> lx (lk, std::adopt_lock);
 
      cv_.wait (lk);
      // mx.unlock()
      // lock.lock()
    }
 
    template <class Lock_T, class Predicate_T>
    inline void
    condition_variable_any::wait (Lock_T& lock, Predicate_T pred)
    {
      while (!pred ())
        wait (lock);
    }
 
    template <class Lock_T, class Clock_T, class Duration_T>
    cv_status
    condition_variable_any::wait_until (
        Lock_T& lock,
        const std::chrono::time_point<Clock_T, Duration_T>& abs_time)
    {
      std::shared_ptr<mutex> mx = mx_;
      std::unique_lock<mutex> lk (*mx);
      lock.unlock ();
      std::unique_ptr<Lock_T, __lock_external> lxx (&lock);
      std::lock_guard<std::unique_lock<mutex>> lx (lk, std::adopt_lock);
 
      return cv_.wait_until (lk, abs_time);
      // mx.unlock()
      // lock.lock()
    }
 
    template <class Lock_T, class Clock_T, class Duration_T, class Predicate_T>
    inline bool
    condition_variable_any::wait_until (
        Lock_T& lock,
        const std::chrono::time_point<Clock_T, Duration_T>& abs_time,
        Predicate_T pred)
    {
      while (!pred ())
        {
          if (wait_until (lock, abs_time) == cv_status::timeout)
            {
              return pred ();
            }
        }
      return true;
    }
 
    template <class Lock_T, class Rep_T, class Period_T>
    inline cv_status
    condition_variable_any::wait_for (
        Lock_T& lock, const std::chrono::duration<Rep_T, Period_T>& rel_time)
    {
      return wait_until (lock, Native_clock::now () + rel_time);
    }
 
    template <class Lock_T, class Rep_T, class Period_T, class Predicate_T>
    inline bool
    condition_variable_any::wait_for (
        Lock_T& lock, const std::chrono::duration<Rep_T, Period_T>& rel_time,
        Predicate_T pred)
    {
      return wait_until (lock, Native_clock::now () + rel_time,
                         std::move (pred));
    }
 
    // ========================================================================
  } /* namespace estd */
} /* namespace os */
 
#pragma GCC diagnostic pop
 
#if defined(OS_HAS_STD_THREADS)
 
namespace std
{
  // Redefine the objects in the std:: namespace.
 
  using cv_status = os::estd::cv_status;
 
  using condition_variable = os::estd::condition_variable;
  using condition_variable_any = os::estd::condition_variable_any;
 
} // namespace std
 
#endif
 
// ----------------------------------------------------------------------------
 
#endif /* CMSIS_PLUS_ESTD_CONDITION_VARIABLE_ */