stk_strategy_rrobin.h

Go to the documentation of this file.

/*
 * SuperTinyKernel™ (STK): Lightweight High-Performance Deterministic C++ RTOS for Embedded Systems.
 *
 * Source: https://github.com/SuperTinyKernel-RTOS
 *
 * Copyright (c) 2022-2026 Neutron Code Limited <stk@neutroncode.com>. All Rights Reserved.
 * License: MIT License, see LICENSE for a full text.
 */
 
#ifndef STK_STRATEGY_RROBIN_H_
#define STK_STRATEGY_RROBIN_H_

 
#include "stk_common.h"
 
namespace stk {

template <bool NoSleepYield> class SwitchStrategyRoundRobinT final : public ITaskSwitchStrategy
{
public:
    enum EConfig
    {
        WEIGHT_API               = 0, 
        SLEEP_EVENT_API          = 1, 
        DEADLINE_MISSED_API      = 0, 
        PRIORITY_INHERITANCE_API = 0, 
        NOSLEEP_YIELD_API        = NoSleepYield, 
        TIMESLICE_API            = 0  
    };

    SwitchStrategyRoundRobinT() : m_tasks(), m_sleep(), m_prev(nullptr)
    {}

    STK_VIRT_DTOR ~SwitchStrategyRoundRobinT() = default;

    void AddTask(IKernelTask *task) override
    {
        STK_ASSERT(task != nullptr);
        STK_ASSERT(task->GetHead() == nullptr);
 
        const bool tail = (m_prev == m_tasks.GetLast());
 
        m_tasks.LinkBack(task);
 
        // if pointer was pointing to the tail, become a tail
        if (tail)
        {
            m_prev = task;
        }
    }

    void RemoveTask(IKernelTask *task) override
    {
        STK_ASSERT(task != nullptr);
        STK_ASSERT(GetSize() != 0);
        STK_ASSERT((task->GetHead() == &m_tasks) || (task->GetHead() == &m_sleep));
 
        if (task->GetHead() == &m_tasks)
        {
            RemoveActive(task);
        }
        else
        {
            m_sleep.Unlink(task);
        }
    }

    IKernelTask *GetNext() override
    {
        IKernelTask *next = m_prev;
 
        if (next != nullptr)
        {
            next   = (*next->GetNext());
            m_prev = next;
        }
 
        return next;
    }

    IKernelTask *GetFirst() override
    {
        STK_ASSERT(GetSize() != 0U);
 
        return (*(!m_tasks.IsEmpty() ? m_tasks.GetFirst() : m_sleep.GetFirst()));
    }

    size_t GetSize() const override
    {
        return m_tasks.GetSize() + m_sleep.GetSize();
    }

    void OnTaskSleep(IKernelTask *task) override
    {
        STK_ASSERT(task != nullptr);
        STK_ASSERT(task->IsSleeping());
        STK_ASSERT(task->GetHead() == &m_tasks);
 
        RemoveActive(task);
        m_sleep.LinkBack(task);
    }

    void OnTaskWake(IKernelTask *task) override
    {
        STK_ASSERT(task != nullptr);
        STK_ASSERT(!task->IsSleeping());
        STK_ASSERT(task->GetHead() == &m_sleep);
 
        m_sleep.Unlink(task);
        AddActive(task);
    }

    bool OnTaskYield(IKernelTask *task) override
    {
        if __stk_constexpr_cpp17 (NoSleepYield)
        {
            STK_ASSERT(task != nullptr);
 
            bool handled = false;
 
            if (task->GetHead() == &m_tasks)
            {
                m_prev  = task; // GetNext() will return task's successor (or task itself if alone)
                handled = true;
            }
 
            return handled;
        }
        else
        {
            STK_UNUSED(task);
            return false;
        }
    }
 
protected:
    STK_NONCOPYABLE_CLASS(SwitchStrategyRoundRobinT);

    void AddActive(IKernelTask *task)
    {
        m_tasks.LinkBack(task);
 
        // update pointer: if all tasks were sleeping, this task will change state
        // of the kernel to active
        if (m_prev == nullptr)
        {
            m_prev = task;
        }
    }

    void RemoveActive(IKernelTask *task)
    {
        IKernelTask *const next = (*task->GetNext());
 
        m_tasks.Unlink(task);
 
        // update pointer: if there are no tasks left GetNext() will return nullptr causing a sleep
        // state for the kernel
        if (next == task)
        {
            m_prev = nullptr;
        }
        else if (m_prev == task)
        {
            // cursor was on the removed task: step back so that GetNext() returns its successor
            m_prev = (*next->GetPrev());
        }
        else
        {
            // cursor is on another task: leave the rotation untouched
        }
    }
 
    IKernelTask::ListHeadType m_tasks; 
    IKernelTask::ListHeadType m_sleep; 
    IKernelTask              *m_prev;  
};

typedef SwitchStrategyRoundRobinT<false> SwitchStrategyRoundRobin;

typedef SwitchStrategyRoundRobinT<false> SwitchStrategyRR;

typedef SwitchStrategyRoundRobinT<true> SwitchStrategyRoundRobinNoSleepYield;

typedef SwitchStrategyRoundRobinT<true> SwitchStrategyRR_NSY;
 
} // namespace stk
 
#endif /* STK_STRATEGY_RROBIN_H_ */