os-sched.h

Go to the documentation of this file.

/*
 * This file is part of the µOS++ distribution.
 *   (https://github.com/micro-os-plus)
 * Copyright (c) 2016 Liviu Ionescu.
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom
 * the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#ifndef CMSIS_PLUS_RTOS_OS_SCHED_H_
#define CMSIS_PLUS_RTOS_OS_SCHED_H_

// ----------------------------------------------------------------------------

#if defined(__cplusplus)

#include <cmsis-plus/rtos/os-decls.h>
#include <cmsis-plus/rtos/os-clocks.h>

// ----------------------------------------------------------------------------

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) */

      } /* 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 rtos */
} /* namespace os */

// ----------------------------------------------------------------------------

#endif /* __cplusplus */

#endif /* CMSIS_PLUS_RTOS_OS_SCHED_H_ */