stk_strategy_fpriority.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_FPRIORITY_H_
#define STK_STRATEGY_FPRIORITY_H_

 
#include "stk_common.h"
 
namespace stk {

template <uint8_t MAX_PRIORITIES>
class SwitchStrategyFixedPriority final : public ITaskSwitchStrategy
{
public:
    enum EConfig
    {
        WEIGHT_API               = 1, 
        SLEEP_EVENT_API          = 1, 
        DEADLINE_MISSED_API      = 0, 
        PRIORITY_INHERITANCE_API = 1  
    };

    enum EPriority
    {
        PRIORITY_HIGHEST      = (MAX_PRIORITIES - 1),     
        PRIORITY_HIGH         = ((MAX_PRIORITIES / 2) + (MAX_PRIORITIES - 1)) / 2, 
        PRIORITY_ABOVE_NORMAL = (MAX_PRIORITIES / 2) + 1, 
        PRIORITY_NORMAL       = (MAX_PRIORITIES / 2),     
        PRIORITY_BELOW_NORMAL = (MAX_PRIORITIES / 2) - 1, 
        PRIORITY_LOWER        = (MAX_PRIORITIES / 4),     
        PRIORITY_ABOVE_LOWEST = (0 + 1),                  
        PRIORITY_LOWEST       = 0                         
    };

    explicit SwitchStrategyFixedPriority() : m_tasks(), m_sleep(), m_ready_bitmap(0U), m_prev()
    {
        STK_STATIC_ASSERT_DESC(MAX_PRIORITIES <= 32U, "MAX_PRIORITIES exceeds 32-bit bitmap width");
    }

    STK_VIRT_DTOR ~SwitchStrategyFixedPriority() = default;

    void AddTask(IKernelTask *task) override
    {
        STK_ASSERT(task != nullptr);
        STK_ASSERT(task->GetHead() == nullptr);
        STK_ASSERT(GetTaskPriority(task) < MAX_PRIORITIES);
 
        const Priority prio = GetTaskPriority(task);
        const bool is_tail = (m_prev[prio] == m_tasks[prio].GetLast());
 
        AddActive(task);
 
        // if pointer was pointing to the tail, become a tail
        if (is_tail)
        {
            m_prev[prio] = task;
        }
    }

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

    IKernelTask *GetNext() override
    {
        IKernelTask *next = nullptr;
 
        if (m_ready_bitmap != 0U)
        {
            const Priority prio = GetHighestReadyPriority(m_ready_bitmap);
 
            next = (*m_prev[prio]->GetNext());
            m_prev[prio] = next;
        }
 
        return next;
    }

    IKernelTask *GetFirst() override
    {
        STK_ASSERT(GetSize() != 0U);
 
        IKernelTask *first_task = nullptr;
 
        if (m_ready_bitmap == 0U)
        {
            first_task = (*m_sleep.GetFirst());
        }
        else
        {
            const Priority prio = GetHighestReadyPriority(m_ready_bitmap);
            first_task = (*m_tasks[prio].GetFirst());
        }
 
        return first_task;
    }

    size_t GetSize() const override
    {
        size_t total = m_sleep.GetSize();
        for (Priority i = 0U; i < MAX_PRIORITIES; ++i)
        {
            total += m_tasks[i].GetSize();
        }
 
        return total;
    }

    void OnTaskSleep(IKernelTask *task) override
    {
        STK_ASSERT(task != nullptr);
        STK_ASSERT(task->IsSleeping());
        STK_ASSERT(task->GetHead() == &m_tasks[GetTaskPriority(task)]);
 
        RemoveActive(task, GetTaskPriority(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);
    }

    void OnTaskWeightChange(IKernelTask *task, Weight old_weight) override
    {
        const Priority old_prio = GetTaskPriorityFromWeight(old_weight);
 
        STK_ASSERT(GetTaskPriority(task) < MAX_PRIORITIES);
        STK_ASSERT(old_prio < MAX_PRIORITIES);
 
        if (task->GetHead() != &m_sleep)
        {
            STK_ASSERT(task->GetHead() == &m_tasks[old_prio]);
 
            // remove from the old priority list
            RemoveActive(task, old_prio);
 
            // re-add to the current priority list
            AddActive(task);
        }
    }
 
protected:
    typedef uint8_t Priority;

    void AddActive(IKernelTask *task)
    {
        const Priority prio = GetTaskPriority(task);
 
        m_tasks[prio].LinkBack(task);
 
        // init pointer
        if (m_tasks[prio].GetSize() == 1U)
        {
            m_prev[prio] = task;
 
            m_ready_bitmap |= (1U << prio);
        }
    }

    void RemoveActive(IKernelTask *task, const Priority prio)
    {
        IKernelTask *next = (*task->GetNext());
 
        m_tasks[prio].Unlink(task);
 
        // update pointer
        if (next != task)
        {
            m_prev[prio] = (*next->GetPrev());
        }
        else
        {
            m_prev[prio] = nullptr;
 
            // this will cause a switch to a lower priority task list
            m_ready_bitmap &= ~(1U << prio);
        }
    }

    static __stk_forceinline Priority GetTaskPriorityFromWeight(int32_t weight)
    {
        return static_cast<Priority>(weight);
    }

    static __stk_forceinline Priority GetTaskPriority(IKernelTask *task)
    {
        return GetTaskPriorityFromWeight(task->GetWeight());
    }

    static __stk_forceinline Priority GetHighestReadyPriority(uint32_t bitmap)
    {
    #if defined(__GNUC__)
        return GetTaskPriorityFromWeight(31U - __builtin_clz(bitmap));
    #else
        for (int8_t i = 31; i >= 0; --i)
        {
            if (bitmap & (1U << i))
            {
                return GetTaskPriorityFromWeight(i);
            }
        }
        return 0;
    #endif
    }
 
private:
    STK_NONCOPYABLE_CLASS(SwitchStrategyFixedPriority);
 
    IKernelTask::ListHeadType m_tasks[MAX_PRIORITIES]; 
    IKernelTask::ListHeadType m_sleep;                 
    uint32_t                  m_ready_bitmap;          
    IKernelTask              *m_prev[MAX_PRIORITIES];  
};

typedef SwitchStrategyFixedPriority<32> SwitchStrategyFP32;
 
} // namespace stk
 
#endif /* STK_STRATEGY_FPRIORITY_H_ */