stk_strategy_edf.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_EDF_H_
#define STK_STRATEGY_EDF_H_

 
#include "stk_common.h"
 
namespace stk {

class SwitchStrategyEDF : public ITaskSwitchStrategy
{
public:
    enum EConfig
    {
        WEIGHT_API          = 0, 
        SLEEP_EVENT_API     = 1, 
        DEADLINE_MISSED_API = 0  
    };

    explicit SwitchStrategyEDF() : m_tasks(), m_sleep()
    {}

    ~SwitchStrategyEDF()
    {}

    void AddTask(IKernelTask *task)
    {
        STK_ASSERT(task != nullptr);
        STK_ASSERT(task->GetHead() == nullptr);
 
        m_tasks.LinkBack(task);
    }

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

    IKernelTask *GetNext()
    {
        if (m_tasks.IsEmpty())
            return nullptr; // idle
 
        IKernelTask *itr = (*m_tasks.GetFirst()), * const start = itr;
        IKernelTask *earliest = itr;
 
        do
        {
            if (itr->GetHrtRelativeDeadline() < earliest->GetHrtRelativeDeadline())
                earliest = itr;
        }
        while ((itr = (*itr->GetNext())) != start);
 
        return earliest;
    }

    IKernelTask *GetFirst() const
    {
        STK_ASSERT(GetSize() != 0U);
 
        if (!m_tasks.IsEmpty())
            return (*m_tasks.GetFirst());
        else
            return (*m_sleep.GetFirst());
    }

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

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

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

    bool OnTaskDeadlineMissed(IKernelTask */*task*/)
    {
        // Budget Overrun API unsupported
        STK_ASSERT(false);
        return false;
    }
 
protected:
    STK_NONCOPYABLE_CLASS(SwitchStrategyEDF);
 
    IKernelTask::ListHeadType m_tasks; 
    IKernelTask::ListHeadType m_sleep; 
};
 
} // namespace stk
 
#endif /* STK_STRATEGY_EDF_H_ */