futex.hpp

Go to the documentation of this file.

 
#ifndef ZPP_INCLUDE_ZPP_FUTEX_HPP
#define ZPP_INCLUDE_ZPP_FUTEX_HPP
 
#ifdef CONFIG_USERSPACE
 
#include <zephyr/kernel.h>
#include <zephyr/sys/__assert.h>
 
#include <chrono>
 
namespace zpp {
 
template<typename T_Futex>
class futex_base
{
public:
  using native_type = struct k_futex;
  using native_pointer = native_type *;
  using native_const_pointer = native_type const *;
protected:
  constexpr futex_base() noexcept
  {
  }
 
public:
  [[nodiscard]] bool wait(int expected) noexcept
  {
    if (futex_wait(native_handle(), expected, K_FOREVER) == 0) {
      return true;
    } else {
      return false;
    }
  }
 
  [[nodiscard]] bool try_wait(int expected) noexcept
  {
    if (futex_wait(native_handle(), expected, K_NO_WAIT) == 0) {
      return true;
    } else {
      return false;
    }
  }
 
  template<class T_Rep, class T_Period>
  [[nodiscard]] bool
  try_wait_for(int expected, const std::chrono::duration<T_Rep, T_Period>& timeout) noexcept
  {
    using namespace std::chrono;
 
    if (futex_wait(native_handle(), expected, to_timeout(timeout)) == 0)
    {
      return true;
    } else {
      return false;
    }
  }
 
  void wake_one() noexcept
  {
    futex_wake(native_handle(), false);
  }
 
  void wake_all() noexcept
  {
    futex_wake(native_handle(), true);
  }
 
  auto native_handle() noexcept -> native_pointer
  {
    return static_cast<T_Futex*>(this)->native_handle();
  }
 
  auto native_handle() const noexcept -> native_const_pointer
  {
    return static_cast<const T_Futex*>(this)->native_handle();
  }
public:
  futex_base(const futex_base&) = delete;
  futex_base(futex_base&&) = delete;
  futex_base& operator=(const futex_base&) = delete;
  futex_base& operator=(futex_base&&) = delete;
};
 
class futex : public futex_base<futex> {
public:
  constexpr auto native_handle() noexcept -> native_pointer
  {
    return &m_futex;
  }
 
  constexpr auto native_handle() const noexcept -> native_const_pointer
  {
    return &m_futex;
  }
private:
  native_type m_futex{};
public:
  futex(const futex&) = delete;
  futex(futex&&) = delete;
  futex& operator=(const futex&) = delete;
  futex& operator=(futex&&) = delete;
};
 
class futex_ref : public futex_base<futex_ref> {
public:
  explicit constexpr futex_ref(native_pointer f) noexcept
    : m_futex_ptr(f)
  {
    __ASSERT_NO_MSG(m_futex_ptr != nullptr);
  }
 
  template<typename T_Futex>
  explicit constexpr futex_ref(T_Futex& f) noexcept
    : m_futex_ptr(f.native_handle())
  {
    __ASSERT_NO_MSG(m_futex_ptr != nullptr);
  }
 
  constexpr futex_ref& operator=(native_pointer f) noexcept
  {
    m_futex_ptr = f;
    __ASSERT_NO_MSG(m_futex_ptr != nullptr);
    return *this;
  }
 
  template<typename T_Futex>
  constexpr futex_ref& operator=(T_Futex& f) noexcept
  {
    m_futex_ptr = f.native_handle();
    __ASSERT_NO_MSG(m_futex_ptr != nullptr);
    return *this;
  }
 
  constexpr auto native_handle() noexcept -> native_pointer
  {
    return m_futex_ptr;
  }
 
  constexpr auto native_handle() const noexcept -> native_const_pointer
  {
    return m_futex_ptr;
  }
private:
  native_pointer m_futex_ptr{ nullptr };
public:
  futex_ref() = delete;
};
 
} // namespace zpp
 
#endif // CONFIG_USERSPACE
 
#endif // ZPP_INCLUDE_ZPP_FUTEX_HPP