thread_prio.hpp

Go to the documentation of this file.

//
// Copyright (c) 2019 Erwin Rol <erwin@erwinrol.com>
//
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef ZPP_INCLUDE_ZPP_THREAD_PRIO_HPP
#define ZPP_INCLUDE_ZPP_THREAD_PRIO_HPP
 
#include <zephyr/kernel.h>
#include <zephyr/sys/__assert.h>
 
namespace zpp {
 
class thread_prio {
public:
  constexpr thread_prio() noexcept
  {
  }
 
  constexpr explicit thread_prio(int prio) noexcept
    : m_prio(prio)
  {
    if (m_prio < -CONFIG_NUM_COOP_PRIORITIES) {
      m_prio = -CONFIG_NUM_COOP_PRIORITIES;
    } else if (m_prio > (CONFIG_NUM_PREEMPT_PRIORITIES - 1)) {
      m_prio = CONFIG_NUM_PREEMPT_PRIORITIES - 1;
    }
 
    __ASSERT_NO_MSG(m_prio == prio);
  }
 
  constexpr int native_value() const noexcept
  {
    return m_prio;
  }
 
  static constexpr thread_prio highest_coop() noexcept
  {
    return thread_prio(-CONFIG_NUM_COOP_PRIORITIES);
  }
 
  static constexpr thread_prio lowest_coop() noexcept
  {
    return thread_prio(-1);
  }
 
  static constexpr thread_prio highest_preempt() noexcept
  {
    return thread_prio(0);
  }
 
  static constexpr thread_prio lowest_preempt() noexcept
  {
    return thread_prio(CONFIG_NUM_PREEMPT_PRIORITIES - 1);
  }
 
  static constexpr thread_prio min_coop_numeric() noexcept
  {
    return highest_coop();
  }
 
  static constexpr thread_prio max_coop_numeric() noexcept
  {
    return lowest_coop();
  }
 
  static constexpr thread_prio min_preempt_numeric() noexcept
  {
    return highest_preempt();
  }
 
  static constexpr thread_prio max_preempt_numeric() noexcept
  {
    return lowest_preempt();
  }
 
  static constexpr thread_prio min_numeric() noexcept
  {
    return min_coop_numeric();
  }
 
  static constexpr thread_prio max_numeric() noexcept
  {
    return max_preempt_numeric();
  }
 
 
  static constexpr thread_prio coop(int prio) noexcept
  {
    return thread_prio( lowest_coop().native_value() - prio );
  }
 
  static constexpr thread_prio preempt(int prio) noexcept
  {
    return (prio >= CONFIG_NUM_PREEMPT_PRIORITIES) ?
      highest_preempt() :
      thread_prio( lowest_preempt().native_value() - prio);
  }
private:
  int m_prio { 0 };
};
 
constexpr bool
operator==(const thread_prio& lhs, const thread_prio& rhs) noexcept
{
  return (lhs.native_value() == rhs.native_value());
}
 
constexpr bool
operator!=(const thread_prio& lhs, const thread_prio& rhs) noexcept
{
  return (lhs.native_value() != rhs.native_value());
}
 
constexpr thread_prio
operator-(thread_prio lhs, int rhs) noexcept
{
  return thread_prio(lhs.native_value() + rhs);
}
 
constexpr thread_prio
operator+(thread_prio lhs, int rhs) noexcept
{
  return thread_prio(lhs.native_value() - rhs);
}
 
inline void print_arg(thread_prio prio) noexcept
{
  printk("%d", prio.native_value());
}
 
} // namespace zpp
 
#endif // ZPP_INCLUDE_ZPP_THREAD_PRIO_HPP