FpySequencer.hpp

Go to the documentation of this file.

// ======================================================================
// \title  FpySequencer.hpp
// \author zimri.leisher
// \brief  hpp file for FpySequencer component implementation class
// ======================================================================

#ifndef FpySequencer_HPP
#define FpySequencer_HPP

#include <random>
#include "Fw/Types/FileNameString.hpp"
#include "Fw/Types/MemAllocator.hpp"
#include "Fw/Types/StringBase.hpp"
#include "Fw/Types/SuccessEnumAc.hpp"
#include "Fw/Types/WaitEnumAc.hpp"
#include "Os/File.hpp"
#include "Svc/FpySequencer/DirectiveIdEnumAc.hpp"
#include "Svc/FpySequencer/FooterSerializableAc.hpp"
#include "Svc/FpySequencer/FppConstantsAc.hpp"
#include "Svc/FpySequencer/FpySequencerComponentAc.hpp"
#include "Svc/FpySequencer/FpySequencer_GoalStateEnumAc.hpp"
#include "Svc/FpySequencer/HeaderSerializableAc.hpp"
#include "Svc/FpySequencer/SequenceSerializableAc.hpp"
#include "Svc/FpySequencer/StatementSerializableAc.hpp"
#include "Svc/Seq/BlockStateEnumAc.hpp"
#include "Utils/Hash/Hash.hpp"
#include "config/FppConstantsAc.hpp"

static_assert(Svc::Fpy::MAX_SEQUENCE_ARG_COUNT <= std::numeric_limits<U8>::max(),
              "Sequence arg count must be below U8 max");
static_assert(Svc::Fpy::MAX_SEQUENCE_STATEMENT_COUNT <= std::numeric_limits<U16>::max(),
              "Sequence statement count must be below U16 max");
static_assert(Svc::Fpy::MAX_STACK_SIZE <= std::numeric_limits<Svc::Fpy::StackSizeType>::max(),
              "Max stack size must be below Svc::Fpy::StackSizeType max");
static_assert(Svc::Fpy::MAX_STACK_SIZE >= static_cast<FwSizeType>(FW_TLM_BUFFER_MAX_SIZE),
              "Max stack size must be greater than max tlm buffer size");
static_assert(Svc::Fpy::MAX_STACK_SIZE >= static_cast<FwSizeType>(FW_PARAM_BUFFER_MAX_SIZE),
              "Max stack size must be greater than max prm buffer size");

namespace Svc {

using Signal = FpySequencer_SequencerStateMachineStateMachineBase::Signal;
using State = FpySequencer_SequencerStateMachineStateMachineBase::State;
using DirectiveError = Fpy::DirectiveErrorCode;

class FpySequencer : public FpySequencerComponentBase {
    friend class FpySequencerTester;

  public:
    union DirectiveUnion {
        FpySequencer_WaitRelDirective waitRel;
        FpySequencer_WaitAbsDirective waitAbs;
        FpySequencer_GotoDirective gotoDirective;
        FpySequencer_IfDirective ifDirective;
        FpySequencer_NoOpDirective noOp;
        FpySequencer_PushTlmValDirective pushTlmVal;
        FpySequencer_PushTlmValAndTimeDirective pushTlmValAndTime;
        FpySequencer_PushPrmDirective pushPrm;
        FpySequencer_ConstCmdDirective constCmd;
        FpySequencer_StackOpDirective stackOp;
        FpySequencer_ExitDirective exit;
        FpySequencer_AllocateDirective allocate;
        FpySequencer_StoreRelConstOffsetDirective storeRelConstOffset;
        FpySequencer_LoadRelDirective loadRel;
        FpySequencer_PushValDirective pushVal;
        FpySequencer_DiscardDirective discard;
        FpySequencer_MemCmpDirective memCmp;
        FpySequencer_StackCmdDirective stackCmd;
        FpySequencer_PushTimeDirective pushTime;
        FpySequencer_SetSeedDirective setSeed;
        FpySequencer_PushRandDirective pushRand;
        FpySequencer_GetFieldDirective getField;
        FpySequencer_PeekDirective peek;
        FpySequencer_StoreRelDirective storeRel;
        FpySequencer_CallDirective call;
        FpySequencer_ReturnDirective returnDirective;
        FpySequencer_LoadAbsDirective loadAbs;
        FpySequencer_StoreAbsDirective storeAbs;
        FpySequencer_StoreAbsConstOffsetDirective storeAbsConstOffset;
        FpySequencer_PopEventDirective popEvent;
        FpySequencer_PopSerializableDirective popSerializable;

        DirectiveUnion() {}
        ~DirectiveUnion() {}
    };

    class Stack {
      public:
        // the byte array of the program stack, storing lvars, operands and function calls
        U8 bytes[Fpy::MAX_STACK_SIZE] = {0};
        // how many bytes high the stack is
        Fpy::StackSizeType size = 0;
        // the byte offset from the start of the stack where the current function's local variables begin.
        // analogous to a 'frame pointer'.
        Fpy::StackSizeType currentFrameStart = 0;

        // pops a value off of the top of the stack
        // converts it from big endian
        template <typename T>
        T pop();

        // pushes a value onto the top of the stack
        // converts it to big endian
        template <typename T>
        void push(T val);

        // pops a byte array from the top of the stack into the destination array
        // does not convert endianness
        void pop(U8* dest, Fpy::StackSizeType size);

        // pushes a byte array to the top of the stack from the source array
        // leaves the source array unmodified
        // does not convert endianness
        void push(const U8* src, Fpy::StackSizeType size);

        // pushes zero bytes to the stack
        void pushZeroes(Fpy::StackSizeType byteCount);

        // returns a pointer to the next unused byte at the top of the stack
        U8* top();

        // Copies data from one region of the stack to another
        // Asserts that both regions are within bounds and do not overlap
        // Does not modify stack size
        void copy(Fpy::StackSizeType destOffset, Fpy::StackSizeType srcOffset, Fpy::StackSizeType copySize);

        // Moves data within the stack (handles overlapping regions)
        // Asserts that both source and destination are within bounds
        // Does not modify stack size
        void move(Fpy::StackSizeType destOffset, Fpy::StackSizeType srcOffset, Fpy::StackSizeType moveSize);
    };

    // ----------------------------------------------------------------------
    // Construction, initialization, and destruction
    // ----------------------------------------------------------------------

    FpySequencer(const char* const compName 
    );

    ~FpySequencer();

  private:
    void RUN_cmdHandler(FwOpcodeType opCode,               
                        U32 cmdSeq,                        
                        const Fw::CmdStringArg& fileName,  
                        const Svc::BlockState& block       
                        ) override;

    void RUN_ARGS_cmdHandler(FwOpcodeType opCode,               
                             U32 cmdSeq,                        
                             const Fw::CmdStringArg& fileName,  
                             const Svc::BlockState& block,      
                             const Svc::SeqArgs& args           
                             ) override;

    void VALIDATE_cmdHandler(FwOpcodeType opCode,              
                             U32 cmdSeq,                       
                             const Fw::CmdStringArg& fileName  
                             ) override;

    void VALIDATE_ARGS_cmdHandler(FwOpcodeType opCode,               
                                  U32 cmdSeq,                        
                                  const Fw::CmdStringArg& fileName,  
                                  const Svc::SeqArgs& buffer         
                                  ) override;

    void RUN_VALIDATED_cmdHandler(FwOpcodeType opCode,          
                                  U32 cmdSeq,                   
                                  const Svc::BlockState& block  
                                  ) override;

    void CANCEL_cmdHandler(FwOpcodeType opCode,  
                           U32 cmdSeq            
                           ) override;

    void SET_BREAKPOINT_cmdHandler(FwOpcodeType opCode,  
                                   U32 cmdSeq,           
                                   U32 stmtIdx,          
                                   bool breakOnce        
                                   ) override;

    void BREAK_cmdHandler(FwOpcodeType opCode,  
                          U32 cmdSeq            
                          ) override;

    void CONTINUE_cmdHandler(FwOpcodeType opCode,  
                             U32 cmdSeq            
                             ) override;

    void CLEAR_BREAKPOINT_cmdHandler(FwOpcodeType opCode,  
                                     U32 cmdSeq            
                                     ) override;

    void STEP_cmdHandler(FwOpcodeType opCode,  
                         U32 cmdSeq            
                         ) override;

    void DUMP_STACK_TO_FILE_cmdHandler(FwOpcodeType opCode,              
                                       U32 cmdSeq,                       
                                       const Fw::CmdStringArg& fileName  
                                       ) override;

    // ----------------------------------------------------------------------
    // Functions to implement for internal state machine actions
    // ----------------------------------------------------------------------

    void Svc_FpySequencer_SequencerStateMachine_action_signalEntered(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setSequenceFilePath(
        SmId smId,                                              
        Svc_FpySequencer_SequencerStateMachine::Signal signal,  
        const Svc::FpySequencer_SequenceExecutionArgs& value    
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setSequenceBlockState(
        SmId smId,                                              
        Svc_FpySequencer_SequencerStateMachine::Signal signal,  
        const Svc::FpySequencer_SequenceExecutionArgs& value    
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setSequenceArguments(
        SmId smId,                                              
        Svc_FpySequencer_SequencerStateMachine::Signal signal,  
        const Svc::FpySequencer_SequenceExecutionArgs& value    
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_validate(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_report_seqSucceeded(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_report_seqCancelled(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setGoalState_RUNNING(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setGoalState_VALID(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setGoalState_IDLE(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_sendCmdResponse_OK(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_sendCmdResponse_EXECUTION_ERROR(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_dispatchStatement(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_clearSequenceFile(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_clearSequenceArguments(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_checkShouldWake(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_resetRuntime(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_checkStatementTimeout(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_incrementSequenceCounter(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_pushArgsToStack(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_clearBreakpoint(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_report_seqBroken(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setBreakpoint(
        SmId smId,                                              
        Svc_FpySequencer_SequencerStateMachine::Signal signal,  
        const Svc::FpySequencer_BreakpointArgs& value           
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setBreakBeforeNextLine(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_clearBreakBeforeNextLine(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_report_seqFailed(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_report_seqStarted(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

  protected:
    // ----------------------------------------------------------------------
    // Functions to implement for internal state machine guards
    // ----------------------------------------------------------------------

    bool Svc_FpySequencer_SequencerStateMachine_guard_goalStateIs_RUNNING(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
    ) const override;

    bool Svc_FpySequencer_SequencerStateMachine_guard_shouldBreak(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
    ) const override;

    bool Svc_FpySequencer_SequencerStateMachine_guard_breakOnce(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
    ) const override;

    // ----------------------------------------------------------------------
    // Handlers to implement for typed input ports
    // ----------------------------------------------------------------------

    void checkTimers_handler(FwIndexType portNum,  
                             U32 context           
                             ) override;

    void cmdResponseIn_handler(FwIndexType portNum,             
                               FwOpcodeType opCode,             
                               U32 cmdSeq,                      
                               const Fw::CmdResponse& response  
                               ) override;

    void seqRunIn_handler(FwIndexType portNum, const Fw::StringBase& filename, const Svc::SeqArgs& args) override;

    void seqCancelIn_handler(FwIndexType portNum  
                             ) override;

    void pingIn_handler(FwIndexType portNum,  
                        U32 key               
                        ) override;

    void tlmWrite_handler(FwIndexType portNum,  
                          U32 context           
                          ) override;

    void directive_waitAbs_internalInterfaceHandler(const FpySequencer_WaitAbsDirective& directive,
                                                    U64 sequenceIndex) override;

    void directive_waitRel_internalInterfaceHandler(const FpySequencer_WaitRelDirective& directive,
                                                    U64 sequenceIndex) override;

    void directive_goto_internalInterfaceHandler(const Svc::FpySequencer_GotoDirective& directive,
                                                 U64 sequenceIndex) override;

    void directive_if_internalInterfaceHandler(const Svc::FpySequencer_IfDirective& directive,
                                               U64 sequenceIndex) override;

    void directive_noOp_internalInterfaceHandler(const Svc::FpySequencer_NoOpDirective& directive,
                                                 U64 sequenceIndex) override;

    void directive_pushTlmVal_internalInterfaceHandler(const Svc::FpySequencer_PushTlmValDirective& directive,
                                                       U64 sequenceIndex) override;

    void directive_pushTlmValAndTime_internalInterfaceHandler(
        const Svc::FpySequencer_PushTlmValAndTimeDirective& directive,
        U64 sequenceIndex) override;

    void directive_pushPrm_internalInterfaceHandler(const Svc::FpySequencer_PushPrmDirective& directive,
                                                    U64 sequenceIndex) override;

    void directive_constCmd_internalInterfaceHandler(const Svc::FpySequencer_ConstCmdDirective& directive,
                                                     U64 sequenceIndex) override;

    void directive_stackOp_internalInterfaceHandler(const Svc::FpySequencer_StackOpDirective& directive,
                                                    U64 sequenceIndex) override;

    void directive_exit_internalInterfaceHandler(const Svc::FpySequencer_ExitDirective& directive,
                                                 U64 sequenceIndex) override;

    void directive_allocate_internalInterfaceHandler(const Svc::FpySequencer_AllocateDirective& directive,
                                                     U64 sequenceIndex) override;

    void directive_storeRelConstOffset_internalInterfaceHandler(
        const Svc::FpySequencer_StoreRelConstOffsetDirective& directive,
        U64 sequenceIndex) override;

    void directive_loadRel_internalInterfaceHandler(const Svc::FpySequencer_LoadRelDirective& directive,
                                                    U64 sequenceIndex) override;

    void directive_pushVal_internalInterfaceHandler(const Svc::FpySequencer_PushValDirective& directive,
                                                    U64 sequenceIndex) override;

    void directive_discard_internalInterfaceHandler(const Svc::FpySequencer_DiscardDirective& directive,
                                                    U64 sequenceIndex) override;

    void directive_memCmp_internalInterfaceHandler(const Svc::FpySequencer_MemCmpDirective& directive,
                                                   U64 sequenceIndex) override;

    void directive_stackCmd_internalInterfaceHandler(const Svc::FpySequencer_StackCmdDirective& directive,
                                                     U64 sequenceIndex) override;

    void directive_pushTime_internalInterfaceHandler(const Svc::FpySequencer_PushTimeDirective& directive,
                                                     U64 sequenceIndex) override;

    void directive_setSeed_internalInterfaceHandler(const Svc::FpySequencer_SetSeedDirective& directive,
                                                    U64 sequenceIndex) override;

    void directive_pushRand_internalInterfaceHandler(const Svc::FpySequencer_PushRandDirective& directive,
                                                     U64 sequenceIndex) override;

    void directive_getField_internalInterfaceHandler(const Svc::FpySequencer_GetFieldDirective& directive,
                                                     U64 sequenceIndex) override;

    void directive_peek_internalInterfaceHandler(const Svc::FpySequencer_PeekDirective& directive,
                                                 U64 sequenceIndex) override;

    void directive_storeRel_internalInterfaceHandler(const Svc::FpySequencer_StoreRelDirective& directive,
                                                     U64 sequenceIndex) override;

    void directive_call_internalInterfaceHandler(const Svc::FpySequencer_CallDirective& directive,
                                                 U64 sequenceIndex) override;

    void directive_return_internalInterfaceHandler(const Svc::FpySequencer_ReturnDirective& directive,
                                                   U64 sequenceIndex) override;

    void directive_loadAbs_internalInterfaceHandler(const Svc::FpySequencer_LoadAbsDirective& directive,
                                                    U64 sequenceIndex) override;

    void directive_storeAbs_internalInterfaceHandler(const Svc::FpySequencer_StoreAbsDirective& directive,
                                                     U64 sequenceIndex) override;

    void directive_storeAbsConstOffset_internalInterfaceHandler(
        const Svc::FpySequencer_StoreAbsConstOffsetDirective& directive,
        U64 sequenceIndex) override;

    void directive_popEvent_internalInterfaceHandler(const Svc::FpySequencer_PopEventDirective& directive,
                                                     U64 sequenceIndex) override;

    void directive_popSerializable_internalInterfaceHandler(const Svc::FpySequencer_PopSerializableDirective& directive,
                                                            U64 sequenceIndex) override;

    void parametersLoaded() override;
    void parameterUpdated(FwPrmIdType id) override;

  public:
    void allocateBuffer(FwEnumStoreType identifier, Fw::MemAllocator& allocator, FwSizeType bytes);

    void deallocateBuffer(Fw::MemAllocator& allocator);

  private:
    static constexpr U32 CRC_INITIAL_VALUE = 0xFFFFFFFFU;

    // allocated at startup
    Fw::ExternalSerializeBuffer m_sequenceBuffer;
    // id of allocator that gave us m_sequenceBuffer
    FwEnumStoreType m_allocatorId;

    // assigned by the user via cmd
    // length is FileNameStringSize
    Fw::FileNameString m_sequenceFilePath;
    // the sequence, loaded in memory
    Fpy::Sequence m_sequenceObj;
    // live running computation of CRC (updated as we read)
    Utils::Hash m_computedCRC;

    // Size of arguments read in current sequence. Used for validation between
    // User provided arguments and what is requested of the sequence.
    Fpy::StackSizeType m_totalExpectedArgSize;

    // whether or not the sequence we're about to run should return immediately or
    // block on completion
    Svc::BlockState m_sequenceBlockState;
    // if we are to block on completion, save the opCode and cmdSeq we should
    // return
    FwOpcodeType m_savedOpCode;
    U32 m_savedCmdSeq;

    // sequence arguments to push to stack when entering RUNNING state
    Svc::SeqArgs m_sequenceArgs{};

    // the goal state is the state that we're trying to reach in the sequencer
    // if it's RUNNING, then we should promptly go to RUNNING once we validate the
    // sequence. if it's VALID, we should wait after VALIDATING
    FpySequencer_GoalState m_goalState;

    // the total number of sequences this sequencer has started since construction
    U64 m_sequencesStarted;
    // the total number of statements this sequencer has dispatched, successfully or
    // otherwise, since construction
    U64 m_statementsDispatched;

    const Fw::String NO_SEQ{"<no seq>"};

    // the runtime state of the sequence. encapsulates all state
    // needed to run the sequence.
    // this is distinct from the state of the sequencer. the
    // sequencer and all its state is really just a shell to load
    // and execute this runtime.
    struct Runtime {
        // the index of the next statement to be executed
        U32 nextStatementIndex = 0;

        // the opcode of the statement that is currently executing
        U8 currentStatementOpcode = Fpy::DirectiveId::INVALID;
        // the opcode of the command that we are currently awaiting, or 0 if we are executing a directive
        FwOpcodeType currentCmdOpcode = 0;
        // the time we dispatched the statement that is currently executing
        Fw::Time currentStatementDispatchTime = Fw::Time();

        // the absolute time we should wait for until returning
        // a statement response
        Fw::Time wakeupTime = Fw::Time();

        // RNG state used by PUSH_RAND and SET_SEED directives during this run
        std::mt19937 rng;
        bool rngSeeded = false;

        Stack stack = Stack();
    } m_runtime;

    // the state of the debugger. debugger is separate from runtime
    // because it can be set up before running the sequence.
    struct BreakpointInfo {
        // whether or not to break at the debug breakpoint index
        bool breakpointInUse = false;
        // whether or not to remove the breakpoint after breaking on it
        bool breakOnlyOnceOnBreakpoint = false;
        // the statement index at which to break, before dispatching
        U32 breakpointIndex = 0;
        // whether or not to break before dispatching the next line,
        // independent of what line it is.
        // can be used in combination with breakpointIndex
        bool breakBeforeNextLine = false;
    } m_breakpoint;

    // debug information about the sequence. only valid in the PAUSED state
    // which you can access via BREAK or SET_BREAKPOINT cmds
    struct DebugInfo {
        // true if there are no statements remaining in the sequence file
        bool reachedEndOfFile = false;
        // true if we were able to deserialize the next statement successfully
        bool nextStatementReadSuccess = false;
        // the opcode of the next statement to dispatch.
        U8 nextStatementOpcode = 0;
        // if the next statement is a cmd directive, the opcode of that cmd
        FwOpcodeType nextCmdOpcode = 0;
        // the index of the next statement we're going to execute
        U32 nextStatementIndex = 0;
        // the size of the stack. store this separately from the real stack size
        // so we can avoid changing this during runtime, only modify it during
        // debug
        Fpy::StackSizeType stackSize = 0;
    } m_debug;

    struct Telemetry {
        // the number of statements that failed to execute
        U64 statementsFailed = 0;
        // the number of sequences successfully completed
        U64 sequencesSucceeded = 0;
        // the number of sequences that failed to validate or execute
        U64 sequencesFailed = 0;
        // the number of sequences that have been cancelled
        U64 sequencesCancelled = 0;

        // the error code of the last directive that ran
        DirectiveError lastDirectiveError = DirectiveError::NO_ERROR;
        // the index of the last directive that errored
        U64 directiveErrorIndex = 0;
        // the opcode of the last directive that errored
        Fpy::DirectiveId directiveErrorId = Fpy::DirectiveId::INVALID;
    } m_tlm;

    // ----------------------------------------------------------------------
    // Validation state
    // ----------------------------------------------------------------------

    // loads the sequence in memory, and does header/crc/integrity checks.
    // return SUCCESS if sequence is valid, FAILURE otherwise
    Fw::Success validate();
    // reads and validates the header from the m_sequenceBuffer
    // return SUCCESS if sequence is valid, FAILURE otherwise
    Fw::Success readHeader();
    // reads and validates the body from the m_sequenceBuffer
    // return SUCCESS if sequence is valid, FAILURE otherwise
    Fw::Success readBody();
    // reads and validates the footer from the m_sequenceBuffer
    // return SUCCESS if sequence is valid, FAILURE otherwise
    Fw::Success readFooter();

    // reads some bytes from the open file into the m_sequenceBuffer.
    // updates the CRC by default, but can be turned off if the contents
    // aren't included in CRC.
    // return success if successful
    Fw::Success readBytes(Os::File& file,
                          FwSizeType readLen,
                          const FpySequencer_FileReadStage& readStage,
                          bool updateCrc = true);

    // ----------------------------------------------------------------------
    // Run state
    // ----------------------------------------------------------------------

    // utility method for updating telemetry based on a directive error code
    void handleDirectiveErrorCode(Fpy::DirectiveId id, DirectiveError err);

    // dispatches the next statement
    Signal dispatchStatement();

    // deserializes a directive from bytes into the Fpy type
    // returns success if able to deserialize, and returns the Fpy type object
    // as a reference, in a union of all the possible directive type objects
    Fw::Success deserializeDirective(const Fpy::Statement& stmt, DirectiveUnion& deserializedDirective);

    // dispatches a deserialized sequencer directive to the right handler.
    void dispatchDirective(const DirectiveUnion& directive, const Fpy::DirectiveId& id);

    // checks whether the currently executing statement timed out
    Signal checkStatementTimeout();

    // checks whether the sequencer should wake from sleeping
    Signal checkShouldWake();

    // return true if state is a substate of RUNNING
    bool isRunningState(State state);

    // return true if a directive dispatched by the given sequence can execute in the current state.
    // otherwise, log a warning
    bool checkDirectiveExpected(Fpy::DirectiveId directive, U64 sequenceIndex);

    // update a struct containing debug telemetry, or defaults if not in debug break
    void updateDebugTelemetryStruct();

    // ----------------------------------------------------------------------
    // Directives
    // ----------------------------------------------------------------------

    // sends a signal based on a signal id
    void sendSignal(Signal signal);

    // dispatches a command, returns whether successful or not
    Fw::Success sendCmd(FwOpcodeType opcode, const U8* argBuf, FwSizeType argBufSize);

    // returns the index of the current statement
    U32 currentStatementIdx();

    // we split these functions up into the internalInterfaceInvoke and these custom member funcs
    // so that we can unit test them easier
    Signal waitRel_directiveHandler(const FpySequencer_WaitRelDirective& directive, DirectiveError& error);
    Signal waitAbs_directiveHandler(const FpySequencer_WaitAbsDirective& directive, DirectiveError& error);
    Signal goto_directiveHandler(const FpySequencer_GotoDirective& directive, DirectiveError& error);
    Signal if_directiveHandler(const FpySequencer_IfDirective& directive, DirectiveError& error);
    Signal noOp_directiveHandler(const FpySequencer_NoOpDirective& directive, DirectiveError& error);
    Signal pushTlmVal_directiveHandler(const FpySequencer_PushTlmValDirective& directive, DirectiveError& error);
    Signal pushTlmValAndTime_directiveHandler(const FpySequencer_PushTlmValAndTimeDirective& directive,
                                              DirectiveError& error);
    Signal pushPrm_directiveHandler(const FpySequencer_PushPrmDirective& directive, DirectiveError& error);
    Signal constCmd_directiveHandler(const FpySequencer_ConstCmdDirective& directive, DirectiveError& error);
    Signal stackOp_directiveHandler(const FpySequencer_StackOpDirective& directive, DirectiveError& error);

    DirectiveError op_or();
    DirectiveError op_and();
    DirectiveError op_ieq();
    DirectiveError op_ine();
    DirectiveError op_ult();
    DirectiveError op_ule();
    DirectiveError op_ugt();
    DirectiveError op_uge();
    DirectiveError op_slt();
    DirectiveError op_sle();
    DirectiveError op_sgt();
    DirectiveError op_sge();
    DirectiveError op_feq();
    DirectiveError op_fne();
    DirectiveError op_flt();
    DirectiveError op_fle();
    DirectiveError op_fgt();
    DirectiveError op_fge();
    DirectiveError op_not();
    DirectiveError op_fpext();
    DirectiveError op_fptrunc();
    DirectiveError op_fptoui();
    DirectiveError op_fptosi();
    DirectiveError op_sitofp();
    DirectiveError op_uitofp();
    DirectiveError op_add();
    DirectiveError op_sub();
    DirectiveError op_mul();
    DirectiveError op_udiv();
    DirectiveError op_sdiv();
    DirectiveError op_umod();
    DirectiveError op_smod();
    DirectiveError op_fadd();
    DirectiveError op_fsub();
    DirectiveError op_fmul();
    DirectiveError op_fdiv();
    DirectiveError op_fpow();
    DirectiveError op_flog();
    DirectiveError op_fmod();
    DirectiveError op_siext_8_64();
    DirectiveError op_siext_16_64();
    DirectiveError op_siext_32_64();
    DirectiveError op_ziext_8_64();
    DirectiveError op_ziext_16_64();
    DirectiveError op_ziext_32_64();
    DirectiveError op_itrunc_64_8();
    DirectiveError op_itrunc_64_16();
    DirectiveError op_itrunc_64_32();
    DirectiveError op_ffloor();
    DirectiveError op_iabs();
    DirectiveError op_fabs();

    Signal exit_directiveHandler(const FpySequencer_ExitDirective& directive, DirectiveError& error);
    Signal allocate_directiveHandler(const FpySequencer_AllocateDirective& directive, DirectiveError& error);
    Signal storeHelper(Fpy::StackSizeType destOffset, Fpy::StackSizeType size, DirectiveError& error);
    Signal loadHelper(Fpy::StackSizeType srcOffset, Fpy::StackSizeType size, DirectiveError& error);
    Signal storeRelConstOffset_directiveHandler(const FpySequencer_StoreRelConstOffsetDirective& directive,
                                                DirectiveError& error);
    Signal loadRel_directiveHandler(const FpySequencer_LoadRelDirective& directive, DirectiveError& error);
    Signal pushVal_directiveHandler(const FpySequencer_PushValDirective& directive, DirectiveError& error);
    Signal discard_directiveHandler(const FpySequencer_DiscardDirective& directive, DirectiveError& error);
    Signal memCmp_directiveHandler(const FpySequencer_MemCmpDirective& directive, DirectiveError& error);
    Signal stackCmd_directiveHandler(const FpySequencer_StackCmdDirective& directive, DirectiveError& error);
    Signal pushTime_directiveHandler(const FpySequencer_PushTimeDirective& directive, DirectiveError& error);
    Signal setSeed_directiveHandler(const FpySequencer_SetSeedDirective& directive, DirectiveError& error);
    Signal pushRand_directiveHandler(const FpySequencer_PushRandDirective& directive, DirectiveError& error);
    Signal getField_directiveHandler(const FpySequencer_GetFieldDirective& directive, DirectiveError& error);
    Signal peek_directiveHandler(const FpySequencer_PeekDirective& directive, DirectiveError& error);
    Signal storeRel_directiveHandler(const FpySequencer_StoreRelDirective& directive, DirectiveError& error);
    Signal call_directiveHandler(const FpySequencer_CallDirective& directive, DirectiveError& error);
    Signal return_directiveHandler(const FpySequencer_ReturnDirective& directive, DirectiveError& error);
    Signal loadAbs_directiveHandler(const FpySequencer_LoadAbsDirective& directive, DirectiveError& error);
    Signal storeAbs_directiveHandler(const FpySequencer_StoreAbsDirective& directive, DirectiveError& error);
    Signal storeAbsConstOffset_directiveHandler(const FpySequencer_StoreAbsConstOffsetDirective& directive,
                                                DirectiveError& error);
    Signal popEvent_directiveHandler(const FpySequencer_PopEventDirective& directive, DirectiveError& error);
    Signal popSerializable_directiveHandler(const FpySequencer_PopSerializableDirective& directive,
                                            DirectiveError& error);
};

}  // namespace Svc

#endif