TaskScheduler.h

Go to the documentation of this file.

/* Copyright (c) 2015-2016 Skyward Experimental Rocketry
 * Authors: Alain Carlucci, Federico Terraneo, Matteo Piazzolla
 *
 * 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.
 */
 
#pragma once
 
#include <ActiveObject.h>
#include <Singleton.h>
#include <debug/debug.h>
#include <diagnostic/PrintLogger.h>
#include <units/Frequency.h>
#include <utils/KernelTime.h>
#include <utils/Stats/Stats.h>
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <list>
#include <map>
#include <queue>
 
#include "TaskSchedulerData.h"
 
namespace Boardcore
{
 
class TaskScheduler : public ActiveObject
{
public:
    using function_t = std::function<void()>;
 
    static constexpr size_t MAX_TASKS = 256;
 
    enum class Policy : uint8_t
    {
        ONE_SHOT,  
        SKIP,      // Skips lost executions and stays aligned with the original
                   // start time.
        RECOVER    
    };
 
    explicit TaskScheduler(miosix::Priority priority = miosix::PRIORITY_MAX -
                                                       1);
 
    size_t addTask(function_t function, uint32_t periodMs,
                   Policy policy     = Policy::RECOVER,
                   int64_t startTick = Kernel::getOldTick())
    {
        auto period    = std::chrono::milliseconds{periodMs};
        auto startTime = std::chrono::time_point<std::chrono::steady_clock>{
            std::chrono::milliseconds{startTick}};
 
        return addTask(function, period, policy, startTime);
    }
 
    size_t addTask(function_t function, Units::Frequency::Hertz frequency,
                   Policy policy = Policy::RECOVER,
                   std::chrono::time_point<std::chrono::steady_clock>
                       startTime = std::chrono::steady_clock::now())
    {
        auto period = std::chrono::nanoseconds{
            static_cast<int64_t>(sToNs(1) / frequency.value())};
 
        return addTask(function, period, policy, startTime);
    }
 
    size_t addTask(function_t function, std::chrono::nanoseconds period,
                   Policy policy = Policy::RECOVER,
                   std::chrono::time_point<std::chrono::steady_clock>
                       startTime = std::chrono::steady_clock::now());
 
    void enableTask(size_t id);
 
    void disableTask(size_t id);
 
    bool start() override;
 
    void stop() override;
 
    std::vector<TaskStatsResult> getTaskStats();
 
private:
    struct Task
    {
        function_t function;
        int64_t period;     
        int64_t startTime;  
        bool enabled;       
        Policy policy;
        int64_t lastCall;  
        Stats activationStats;  
        Stats periodStats;      
        Stats workloadStats;    
        uint32_t missedEvents;  
        uint32_t failedEvents;  
 
        Task();
 
        explicit Task(function_t function, int64_t period, Policy policy,
                      int64_t startTime);
 
        // Delete copy constructor and copy assignment operator to avoid copying
        // and force moving
        Task(const Task& other)            = delete;
        Task& operator=(const Task& other) = delete;
 
        // Define a move constructor and a move assignment operator to avoid
        // copying std::function
        Task(Task&& other)            = default;
        Task& operator=(Task&& other) = default;
 
        bool empty() const { return !function; }
    };
 
    struct Event
    {
        size_t taskId;     
        int64_t nextTime;  
 
        Event(size_t taskId, int64_t nextTime)
            : taskId(taskId), nextTime(nextTime)
        {
        }
 
        bool operator>(const Event& other) const
        {
            return this->nextTime > other.nextTime;
        }
    };
 
    // Use `std::greater` as the comparator to have elements with the lowest
    // time first. Requires operator `>` to be defined for Event.
    using EventQueue =
        std::priority_queue<Event, std::vector<Event>, std::greater<Event>>;
 
    static EventQueue makeAgenda();
 
    void populateAgenda();
 
    void run() override;
 
    void updateStats(const Event& event, int64_t startTime, int64_t endTime);
 
    void enqueue(Event event, int64_t startTime);
 
    static TaskStatsResult fromTaskIdPairToStatsResult(const Task& task,
                                                       size_t id)
    {
        return TaskStatsResult{id,
                               std::chrono::nanoseconds{task.period},
                               task.activationStats.getStats(),
                               task.periodStats.getStats(),
                               task.workloadStats.getStats(),
                               task.missedEvents,
                               task.failedEvents};
    }
 
    miosix::FastMutex mutex;  
    std::vector<Task> tasks;  
    miosix::ConditionVariable condvar;  
    EventQueue agenda;                  
 
    PrintLogger logger = Logging::getLogger("taskscheduler");
};
 
}  // namespace Boardcore