os-sched.h

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.
 */
 
#ifndef CMSIS_PLUS_RTOS_OS_SCHED_H_
#define CMSIS_PLUS_RTOS_OS_SCHED_H_
 
// ----------------------------------------------------------------------------
 
#if defined(__cplusplus)
 
// ----------------------------------------------------------------------------
 
#if defined(OS_USE_OS_APP_CONFIG_H)
#include <cmsis-plus/os-app-config.h>
#endif
 
#include <cmsis-plus/rtos/os-decls.h>
#include <cmsis-plus/rtos/os-clocks.h>
 
// ----------------------------------------------------------------------------
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
#endif
 
// ----------------------------------------------------------------------------
 
namespace os
{
  namespace rtos
  {
    namespace scheduler
    {
 
      extern bool is_started_;
 
#if !defined(OS_USE_RTOS_PORT_SCHEDULER)
      extern bool is_preemptive_;
      extern thread* volatile current_thread_;
      extern internal::ready_threads_list ready_threads_list_;
#endif /* !defined(OS_USE_RTOS_PORT_SCHEDULER) */
 
      extern internal::terminated_threads_list terminated_threads_list_;
 
      result_t
      initialize (void);
 
      [[noreturn]] void
      start (void);
 
      bool
      started (void);
 
      state_t
      lock (void);
 
      state_t
      unlock (void);
 
      state_t
      locked (state_t state);
 
      bool
      locked (void);
 
      bool
      preemptive (void);
 
      bool
      preemptive (bool state);
 
      // ----------------------------------------------------------------------
 
      void
      internal_switch_threads (void);
 
      // ======================================================================
      class critical_section
      {
      public:
        critical_section ();
 
        // The rule of five.
        critical_section (const critical_section&) = delete;
        critical_section (critical_section&&) = delete;
        critical_section&
        operator= (const critical_section&)
            = delete;
        critical_section&
        operator= (critical_section&&)
            = delete;
 
        ~critical_section ();
 
      protected:
        const state_t state_;
 
      };
 
      // ======================================================================
 
      class uncritical_section
      {
      public:
        uncritical_section ();
 
        // The rule of five.
        uncritical_section (const uncritical_section&) = delete;
        uncritical_section (uncritical_section&&) = delete;
        uncritical_section&
        operator= (const uncritical_section&)
            = delete;
        uncritical_section&
        operator= (uncritical_section&&)
            = delete;
 
        ~uncritical_section ();
 
      protected:
        const state_t state_;
 
      };
 
      // ======================================================================
 
      class lockable
      {
      public:
        constexpr lockable ();
 
        // The rule of five.
        lockable (const lockable&) = delete;
        lockable (lockable&&) = delete;
        lockable&
        operator= (const lockable&)
            = delete;
        lockable&
        operator= (lockable&&)
            = delete;
 
        ~lockable ();
 
      public:
        void
        lock (void);
 
        bool
        try_lock (void);
 
        void
        unlock (void);
 
      protected:
        state_t state_ = 0;
 
      };
 
      // ----------------------------------------------------------------------
 
      namespace statistics
      {
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES)
 
        rtos::statistics::counter_t
        context_switches (void);
 
        extern rtos::statistics::counter_t context_switches_;
 
#endif /* defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES) */
 
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES)
 
        rtos::statistics::duration_t
        cpu_cycles (void);
 
        extern clock::timestamp_t switch_timestamp_;
        extern rtos::statistics::duration_t cpu_cycles_;
 
#endif /* defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES) */
 
      } /* namespace statistics */
    } /* namespace scheduler */
 
    namespace interrupts
    {
      bool
      in_handler_mode (void);
 
      // ======================================================================
 
      // TODO: define all levels of critical sections
      // (kernel, real-time(level), complete)
 
      // TODO: make template, parameter IRQ level
 
      class critical_section
      {
      public:
        critical_section ();
 
        // The rule of five.
        critical_section (const critical_section&) = delete;
        critical_section (critical_section&&) = delete;
        critical_section&
        operator= (const critical_section&)
            = delete;
        critical_section&
        operator= (critical_section&&)
            = delete;
 
        ~critical_section ();
 
      public:
        static state_t
        enter (void);
 
        static void
        exit (state_t state);
 
      protected:
        const state_t state_;
 
      };
 
      // ======================================================================
 
      class uncritical_section
      {
      public:
        uncritical_section ();
 
        // The rule of five.
        uncritical_section (const uncritical_section&) = delete;
        uncritical_section (uncritical_section&&) = delete;
        uncritical_section&
        operator= (const uncritical_section&)
            = delete;
        uncritical_section&
        operator= (uncritical_section&&)
            = delete;
 
        ~uncritical_section ();
 
      public:
        static state_t
        enter (void);
 
        static void
        exit (state_t state);
 
      protected:
        const state_t state_;
 
      };
 
      // ======================================================================
 
      class lockable
      {
      public:
        constexpr lockable ();
 
        ~lockable ();
 
        // The rule of five.
        lockable (const lockable&) = delete;
        lockable (lockable&&) = delete;
        lockable&
        operator= (const lockable&)
            = delete;
        lockable&
        operator= (lockable&&)
            = delete;
 
      public:
        void
        lock (void);
 
        bool
        try_lock (void);
 
        void
        unlock (void);
 
      protected:
        state_t state_;
 
      };
 
    } /* namespace interrupts */
  } /* namespace rtos */
} /* namespace os */
 
// ===== Inline & template implementations ====================================
 
namespace os
{
  namespace rtos
  {
    namespace scheduler
    {
      inline bool
      started (void)
      {
        return is_started_;
      }
 
      inline bool
      preemptive (void)
      {
#if !defined(OS_USE_RTOS_PORT_SCHEDULER)
        return is_preemptive_;
#else
        return port::scheduler::preemptive ();
#endif
      }
 
      inline bool
      locked (void)
      {
        return port::scheduler::locked ();
      }
 
      inline state_t
      lock (void)
      {
        return port::scheduler::lock ();
      }
 
      inline state_t
      unlock (void)
      {
        return port::scheduler::unlock ();
      }
 
      inline state_t
      locked (state_t state)
      {
        return port::scheduler::locked (state);
      }
 
      inline critical_section::critical_section () : state_ (lock ())
      {
#if defined(OS_TRACE_RTOS_SCHEDULER)
        trace::printf ("{C ");
#endif
      }
 
      inline critical_section::~critical_section ()
      {
#if defined(OS_TRACE_RTOS_SCHEDULER)
        trace::printf (" C}");
#endif
        locked (state_);
      }
 
      inline uncritical_section::uncritical_section () : state_ (unlock ())
      {
#if defined(OS_TRACE_RTOS_SCHEDULER)
        trace::printf ("{U ");
#endif
      }
 
      inline uncritical_section::~uncritical_section ()
      {
#if defined(OS_TRACE_RTOS_SCHEDULER)
        trace::printf (" U}");
#endif
        locked (state_);
      }
 
      constexpr lockable::lockable () : state_ (port::scheduler::state::init)
      {
      }
 
      inline lockable::~lockable ()
      {
      }
 
      inline void
      lockable::lock (void)
      {
        state_ = scheduler::lock ();
      }
 
      inline bool
      lockable::try_lock (void)
      {
        state_ = scheduler::lock ();
        return true;
      }
 
      inline void
      lockable::unlock (void)
      {
        scheduler::locked (state_);
      }
 
      namespace statistics
      {
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES)
 
        inline rtos::statistics::counter_t
        context_switches (void)
        {
          return context_switches_;
        }
 
#endif /* defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES) */
 
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES)
 
        inline rtos::statistics::duration_t
        cpu_cycles (void)
        {
          return cpu_cycles_;
        }
 
#endif /* defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES) */
 
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES) \
    || defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES)
 
        inline void
        clear (void)
        {
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES)
          context_switches_ = 0;
#endif /* defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES) */
 
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES)
          cpu_cycles_ = 0;
#endif /* defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES) */
        }
 
#endif /* defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES) \
  || defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES) */
 
      } /* namespace statistics */
 
    } /* namespace scheduler */
 
    // ========================================================================
 
    namespace interrupts
    {
      inline bool __attribute__ ((always_inline))
      in_handler_mode (void)
      {
        return port::interrupts::in_handler_mode ();
      }
 
      inline __attribute__ ((always_inline))
      critical_section::critical_section ()
          : state_ (enter ())
      {
      }
 
      inline __attribute__ ((always_inline))
      critical_section::~critical_section ()
      {
        exit (state_);
      }
 
      inline state_t __attribute__ ((always_inline))
      critical_section::enter (void)
      {
        return port::interrupts::critical_section::enter ();
      }
 
      inline void __attribute__ ((always_inline))
      critical_section::exit (state_t state)
      {
        port::interrupts::critical_section::exit (state);
      }
 
      // ======================================================================
 
      inline __attribute__ ((always_inline))
      uncritical_section::uncritical_section ()
          : state_ (enter ())
      {
      }
 
      inline __attribute__ ((always_inline))
      uncritical_section::~uncritical_section ()
      {
        exit (state_);
      }
 
      inline state_t __attribute__ ((always_inline))
      uncritical_section::enter (void)
      {
        return port::interrupts::uncritical_section::enter ();
      }
 
      inline void __attribute__ ((always_inline))
      uncritical_section::exit (state_t state)
      {
        port::interrupts::uncritical_section::exit (state);
      }
 
      // ======================================================================
 
      constexpr lockable::lockable () : state_ (port::interrupts::state::init)
      {
      }
 
      inline __attribute__ ((always_inline)) lockable::~lockable ()
      {
      }
 
      inline void __attribute__ ((always_inline))
      lockable::lock (void)
      {
        state_ = critical_section::enter ();
      }
 
      inline bool __attribute__ ((always_inline))
      lockable::try_lock (void)
      {
        state_ = critical_section::enter ();
        return true;
      }
 
      inline void __attribute__ ((always_inline))
      lockable::unlock (void)
      {
        critical_section::exit (state_);
      }
 
      // ======================================================================
    } // namespace interrupts
 
  } /* namespace rtos */
} /* namespace os */
 
#pragma GCC diagnostic pop
 
// ----------------------------------------------------------------------------
 
#endif /* __cplusplus */
 
// ----------------------------------------------------------------------------
 
#endif /* CMSIS_PLUS_RTOS_OS_SCHED_H_ */