stk_strategy_swrrobin.h

Go to the documentation of this file.

/*
 * SuperTinyKernel(TM) RTOS: 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_SWRROBIN_H_
#define STK_STRATEGY_SWRROBIN_H_

 
#include "stk_common.h"
 
namespace stk {

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

    explicit SwitchStrategySmoothWeightedRoundRobinT() : m_tasks(), m_sleep(), m_yielded(), m_total_weight(0)
    {}

    STK_VIRT_DTOR ~SwitchStrategySmoothWeightedRoundRobinT() = default;

    void AddTask(IKernelTask *task) override
    {
        STK_ASSERT(task != nullptr);
        STK_ASSERT((task->GetWeight() > 0) && (task->GetWeight() <= 0x7FFFFF)); // must not be negative, max 24-bit number
 
        task->SetCurrentWeight(NO_WEIGHT);
 
        AddActive(task);
    }

    void RemoveTask(IKernelTask *task) override
    {
        STK_ASSERT(task != nullptr);
        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 = nullptr;
 
        if (!m_tasks.IsEmpty())
        {
            IKernelTask *skip = nullptr;
 
            if __stk_constexpr_cpp17 (NoSleepYield)
            {
                skip         = m_yielded[0]; // one-shot: excluded from this selection only
                m_yielded[0] = nullptr;
            }
            else
            {
                STK_UNUSED(skip);
            }
 
            IKernelTask *itr         = (*m_tasks.GetFirst());
            IKernelTask *const start = itr;
            int32_t max_weight       = INT32_MIN;
 
            do
            {
                const int32_t candidate_weight = itr->GetCurrentWeight() + itr->GetWeight();
                itr->SetCurrentWeight(candidate_weight); // yielding task still accrues weight
 
                if __stk_constexpr_cpp17 (NoSleepYield)
                {
                    if ((itr != skip) && (candidate_weight > max_weight))
                    {
                        max_weight = candidate_weight;
                        next = itr;
                    }
                }
                else
                {
                    if (candidate_weight > max_weight)
                    {
                        max_weight = candidate_weight;
                        next = itr;
                    }
                }
 
                itr = (*itr->GetNext());
            }
            while (itr != start);
 
            if __stk_constexpr_cpp17 (NoSleepYield)
            {
                // yielding task is the only runnable task: nobody to hand over to
                if (next == nullptr)
                {
                    STK_ASSERT(skip != nullptr);
 
                    next       = skip;
                    max_weight = skip->GetCurrentWeight();
                }
            }
 
            STK_ASSERT(next != nullptr);
 
            next->SetCurrentWeight(max_weight - m_total_weight);
        }
 
        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);
 
        // boost priority of the previously sleeping task, this resembles to a RR pattern
        // with tasks having equal weights
        task->SetCurrentWeight(m_total_weight);
 
        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_yielded[0] = task; // excluded from the next selection only
                handled      = true;
            }
 
            return handled;
        }
        else
        {
            STK_UNUSED(task);
            return false;
        }
    }
 
private:
    STK_NONCOPYABLE_CLASS(SwitchStrategySmoothWeightedRoundRobinT);

    void AddActive(IKernelTask *task)
    {
        m_tasks.LinkBack(task);
        m_total_weight += task->GetWeight();
    }

    void RemoveActive(IKernelTask *task)
    {
        if __stk_constexpr_cpp17 (NoSleepYield)
        {
            // do not leave a dangling pointer to a task that is leaving the runnable set
            if (m_yielded[0] == task)
            {
                m_yielded[0] = nullptr;
            }
        }
 
        m_tasks.Unlink(task);
        m_total_weight -= task->GetWeight();
    }
 
    IKernelTask::ListHeadType m_tasks;        
    IKernelTask::ListHeadType m_sleep;        
    IKernelTask              *m_yielded[STK_ALLOCATE_COUNT<NoSleepYield, 1U, 1U, 0U>::Value]; 
    int32_t                   m_total_weight; 
};

typedef SwitchStrategySmoothWeightedRoundRobinT<false> SwitchStrategySmoothWeightedRoundRobin;

typedef SwitchStrategySmoothWeightedRoundRobinT<false> SwitchStrategySWRR;

typedef SwitchStrategySmoothWeightedRoundRobinT<true> SwitchStrategySmoothWeightedRoundRobinNoSleepYield;

typedef SwitchStrategySmoothWeightedRoundRobinT<true> SwitchStrategySWRR_NSY;
 
} // namespace stk
 
#endif /* STK_STRATEGY_SWRROBIN_H_ */