TableScheduler.hpp

Go to the documentation of this file.

/******************************************************************************
* Copyright (c) ATTX INC 2025. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the
* proprietary and confidential information of ATTX, INC. The Software is
* furnished under a license agreement between ATTX and the user organization
* and may be used or copied only in accordance with the terms of the agreement.
* Refer to 'license/attx_license.adoc' for standard license terms.
*
* EXPORT CONTROL NOTICE: THIS SOFTWARE MAY INCLUDE CONTENT CONTROLLED UNDER THE
* INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) OR THE EXPORT ADMINISTRATION
* REGULATIONS (EAR99). No part of the Software may be used, reproduced, or
* transmitted in any form or by any means, for any purpose, without the express
* written permission of ATTX INC.
******************************************************************************/
/*
Tabular scheduler header file
 
Author: Alex Reynolds
*/
#ifndef SCHEDULES_TABLE_SCHEDULER_H
#define SCHEDULES_TABLE_SCHEDULER_H
 
#include "flight/Scheduler.h"
#include "flight/OS.h"
#include "flight/FlightExecutive.h"
#include "core/clockwerkerrors.h"
#include "flight/appmacros.h"
#include "telemetry/tlm_Executive.h"
 
namespace warpos { 
    template <int16 N>
    class TableScheduler : public Scheduler {
    public:
        TableScheduler(OS& os);
 
        ~TableScheduler() {}

        virtual int16 startup() override;

        virtual int16 step(const clockwerk::Time& step_val) override;

        virtual int16 run() override;

        virtual int16 registerApp(App& app, int16 slot) override;

        virtual int16 unregisterApp(int16 slot) override;

        uint8 taskFailures() {return _tlm_error.error_count;}

        uint16 currentSlot() {return _current_slot;}

        uint8 scheduleExceedances() {return _tlm_overrun.overrun_count;}

        const tlm_executive_schedule_overrun& lastExceedance() {return _tlm_overrun;}

        const tlm_executive_app_error& lastTaskFailure() {return _tlm_error;}

        const clockwerk::Time& timePerSlot() {return _step_size;}

        const App* lastAppRun() {return _schedule_array[_current_slot];}
    protected:
        uint16 _getNextSlot(uint16 current_slot);

        OS& _os;

        App* _schedule_array[N];

        bool _scheduler_initialized = false;
 
        int16 _current_slot = 0;                                    
        int16 _end_slot = 0;                                        
        uint32 _nsec_per_slot = clockwerk::NSEC_PER_SEC_I/N;        
        clockwerk::Time _step_size;                                 

        int16 _error = NO_ERROR;
 
        // Variables to hold telemetry and logging stuff
        char _print_buf[200];
        tlm_executive_app_error _tlm_error;
        tlm_executive_schedule_overrun _tlm_overrun;
    };
 
    template<int16 N>
    TableScheduler<N>::TableScheduler(OS& os)
    : Scheduler(), _os(os) {
        // Assert that our schedule has 1000 or fewer slots
        static_assert(N <= 1000, "Table scheduler cannot be broken into more than 1,000 slots");
 
        _step_size.setTime(0, _nsec_per_slot);
 
        // Assign nullptrs to every slot to start
        for(uint16 i = 0; i < N; i++) {
            _schedule_array[i] = nullptr;
        }
 
        // Register telemetry
        _tlm_error.error_count = 0;
        _tlm_overrun.overrun_count = 0;
    }
 
    template<int16 N>
    int16 TableScheduler<N>::registerApp(App& app, int16 slot) {
        // Check that our slot lies on our table
        if(slot >= N) {
            LOG_SCHEDULER(LOG_ERROR, "Schedule slot exceeds table length. App:")
            LOG_SCHEDULER(LOG_ERROR, app.name())
            return ERROR_INVALID_RANGE;
        }
        // And check that our slot is not already occupied
        if(_schedule_array[slot] != nullptr) {
            LOG_SCHEDULER(LOG_ERROR, "Schedule slot is not empty. Registering App:")
            LOG_SCHEDULER(LOG_ERROR, app.name())
            LOG_SCHEDULER(LOG_ERROR, "Occupied by:")
            LOG_SCHEDULER(LOG_ERROR, _schedule_array[slot]->name())
            return ERROR_TREE_NAME_EXISTS;
        }
 
        LOG_SCHEDULER(LOG_DEBUG, "Successfully registered app in table scheduler. Name:")
        LOG_SCHEDULER(LOG_DEBUG, app.name())
 
        _schedule_array[slot] = &app;
        return NO_ERROR;
    }
 
    template<int16 N>
    int16 TableScheduler<N>::unregisterApp(int16 slot) {
        if(slot >= N) {
            return ERROR_INVALID_RANGE;
        }
 
        LOG_SCHEDULER(LOG_DEBUG, "Successfully unregistered app in table scheduler. Name:")
        LOG_SCHEDULER(LOG_DEBUG, _schedule_array[slot]->name())
 
        _schedule_array[slot] = nullptr;
        return NO_ERROR;
    }
 
    template<int16 N>
    int16 TableScheduler<N>::startup() {
        for(uint16 i = 0; i < N; i++) {
            if(_schedule_array[i] != nullptr) {
                if(!_schedule_array[i]->isStarted()) {
                    _error = _schedule_array[i]->startup();
 
                    // Catch, log, and telemeter errors
                    if(_error) {
                        sprintf(_print_buf, "Error caught in startup on task %s / slot %i / code %i", _schedule_array[_current_slot]->name(), _current_slot, _error);
                        LOG_SCHEDULER(LOG_ERROR, _print_buf)
 
                        _tlm_error.app_apid = _schedule_array[i]->apid();
                        _tlm_error.error_code = _error;
                        _tlm_error.error_count++;
                        _tlm_error.schedule_slot = -1;
                        if(_exc_ptr) {
                            _exc_ptr->sendStoreTlm(_tlm_error);
                        }
                    }
                }
            }
        }
 
        return NO_ERROR;
    }
 
    template<int16 N>
    int16 TableScheduler<N>::step(const clockwerk::Time &ref_time) {
        // Calculate our current schedule slot
        _current_slot = ref_time.nsec()/_nsec_per_slot;
 
        // If the scheduler has not initialized and our current step is not 0 (i.e. start) we want to
        // wait for slot 0 to come around so we are aligned to a second time boundary.
        if(!_scheduler_initialized && _current_slot) {
            return WARN_SCH_WAIT_FOR_INIT;
        }
        _scheduler_initialized = true;
 
        // Run our schedule slot if it is occupied
        if(_schedule_array[_current_slot] == nullptr) {
            return NO_ERROR;
        } else {
            _error = _schedule_array[_current_slot]->step();
        }
 
        // Catalog our error if our task failed
        if(_error) {
            sprintf(_print_buf, "Error caught in run on task %s / slot %i / code %i", _schedule_array[_current_slot]->name(), _current_slot, _error);
            LOG_SCHEDULER(LOG_ERROR, _print_buf)
 
            _tlm_error.app_apid = _schedule_array[_current_slot]->apid();
            _tlm_error.error_code = _error;
            _tlm_error.error_count++;
            _tlm_error.schedule_slot = _current_slot;
            if(_exc_ptr) {
                _exc_ptr->sendStoreTlm(_tlm_error);
            }
        }
 
        // And check for overrun on our step
        _end_slot = _os.systemTime().nsec()/_nsec_per_slot;
 
        // If our end slot is not our current slot, we need to mark
        // our overrun
        if(_end_slot != _current_slot) {
            // Get the index of the slot after current
            int idx = _current_slot;
 
            // Loop until idx matches end slot. This is safe (cannot go infinite) because end slot must live in
            // our slot range and we circle back, so at some point we must reach end slot
            while(idx != _end_slot) {
                idx++;              // Increment
                if(idx == N) {
                    idx = 0;        // Loop back to 0 if we hit N
                }
 
                if(_schedule_array[idx] != nullptr) {
                    sprintf(_print_buf, "Detected overrun on task %s / slot %i / return slot %i", _schedule_array[_current_slot]->name(), _current_slot, _end_slot);
                    LOG_SCHEDULER(LOG_ERROR, _print_buf)
 
                    _tlm_overrun.app_apid = _schedule_array[_current_slot]->apid();
                    _tlm_overrun.schedule_slot = _current_slot;
                    _tlm_overrun.terminating_slot = _end_slot;
                    _tlm_overrun.overrun_count++;
                    if(_exc_ptr) {
                        _exc_ptr->sendStoreTlm(_tlm_overrun);
                    }
                    return NO_ERROR;
                }
            }
        }
 
        return NO_ERROR;
    }
 
    template<int16 N>
    int16 TableScheduler<N>::run() {
        // Calculate our first start time. We should start on a system time rollover boundary, so here
        // get our os time and set the next slot start to be at an increment from our current time on
        // slot 0
        clockwerk::Time current_time = _os.systemTime();
        clockwerk::Time next_slot_start(current_time.sec() + 1, 0);
 
        while(!_is_terminated) {
            // Block until we reach our next slot time
            while(current_time < next_slot_start) {
                current_time = _os.systemTime();
            }
 
            // Step our scheduler
            step(current_time);
 
            // Figure out our next schedule slot start time and set us up to wait for that
            _os.systemTime().add(_step_size, next_slot_start);
            next_slot_start.setTime(next_slot_start.sec(),
                                    _nsec_per_slot*(next_slot_start.nsec()/_nsec_per_slot));
 
            // And OS sleep this thread until we're ready to start again. We'll still block
            // until start, but this yields to other tasks outside the schedule which
            // may want to run
            _os.delayUntil(next_slot_start);
        }
 
        return NO_ERROR;
    }
 
    template<int16 N>
    uint16 TableScheduler<N>::_getNextSlot(uint16 current_slot) {
        int16 next = current_slot + 1;
        if(next == N) {
            return 0;
        }
        return next;
    }
}
 
#endif