condition_variable

Go to the documentation of this file.

/*
 * This file is part of the µOS++ distribution.
 *   (https://github.com/micro-os-plus)
 * Copyright (c) 2016-2023 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;
 
}
 
#endif
 
// ----------------------------------------------------------------------------
 
#endif /* CMSIS_PLUS_ESTD_CONDITION_VARIABLE_ */