ComQueue.hpp

Go to the documentation of this file.

// ======================================================================
// \title  ComQueue.hpp
// \author vbai
// \brief  hpp file for ComQueue component implementation class
// ======================================================================

#ifndef Svc_ComQueue_HPP
#define Svc_ComQueue_HPP

#include <Fw/Buffer/Buffer.hpp>
#include <Fw/Com/ComBuffer.hpp>
#include <Svc/ComQueue/ComQueueComponentAc.hpp>
#include <Utils/Types/Queue.hpp>
#include <atomic>
#include <limits>
#include "Fw/Types/MemAllocator.hpp"
#include "Os/Mutex.hpp"

namespace Svc {

// ----------------------------------------------------------------------
// Types
// ----------------------------------------------------------------------

class ComQueue final : public ComQueueComponentBase {
    // Added to enable easy testing of set queue priority command
    friend class ComQueueTester;

    enum BufferState { OWNED, UNOWNED };

  public:
    static const FwIndexType COM_PORT_COUNT = ComQueueComponentBase::NUM_COMPACKETQUEUEIN_INPUT_PORTS;

    static const FwIndexType BUFFER_PORT_COUNT = ComQueueComponentBase::NUM_BUFFERQUEUEIN_INPUT_PORTS;

    static_assert((COM_PORT_COUNT + BUFFER_PORT_COUNT) <= std::numeric_limits<FwIndexType>::max(),
                  "FwIndexType not large enough to hold com and buffer ports");
    static const FwIndexType TOTAL_PORT_COUNT = COM_PORT_COUNT + BUFFER_PORT_COUNT;

    struct QueueConfigurationEntry {
        FwSizeType depth;                       
        FwIndexType priority;                   
        Types::QueueMode mode;                  
        Types::QueueOverflowMode overflowMode;  
    };

    struct QueueConfigurationTable {
        QueueConfigurationEntry entries[TOTAL_PORT_COUNT];
        QueueConfigurationTable();
    };

  private:
    // ----------------------------------------------------------------------
    // Internal data structures
    // ----------------------------------------------------------------------

    struct QueueMetadata {
        FwSizeType depth;                       
        FwIndexType priority;                   
        Types::QueueMode mode;                  
        Types::QueueOverflowMode overflowMode;  
        FwIndexType index;                      
        FwSizeType msgSize;                     
    };

    enum SendState {
        READY,   
        WAITING  
    };

  public:
    // ----------------------------------------------------------------------
    // Construction, initialization, and destruction
    // ----------------------------------------------------------------------

    ComQueue(const char* const compName 
    );

    ~ComQueue();

    void configure(
        const QueueConfigurationTable& queueConfig,  
        FwEnumStoreType allocationId,                
        Fw::MemAllocator& allocator                  
    );

    void cleanup();

  private:
    // ----------------------------------------------------------------------
    // Handler implementations for commands
    // ----------------------------------------------------------------------

    void FLUSH_QUEUE_cmdHandler(FwOpcodeType opCode,              
                                U32 cmdSeq,                       
                                const Svc::QueueType& queueType,  
                                FwIndexType indexType  
                                ) override;

    void FLUSH_ALL_QUEUES_cmdHandler(FwOpcodeType opCode,  
                                     U32 cmdSeq            
                                     ) override;

    void SET_QUEUE_PRIORITY_cmdHandler(
        FwOpcodeType opCode,              
        U32 cmdSeq,                       
        const Svc::QueueType& queueType,  
        FwIndexType indexType,            
        FwIndexType newPriority           
        ) override;

  private:
    // ----------------------------------------------------------------------
    // Handler implementations for user-defined typed input ports
    // ----------------------------------------------------------------------

    void bufferQueueIn_handler(const FwIndexType portNum, 
                               Fw::Buffer& fwBuffer ) override;

    void comPacketQueueIn_handler(const FwIndexType portNum, 
                                  Fw::ComBuffer& data,       
                                  U32 context                
                                  ) override;

    void comStatusIn_handler(const FwIndexType portNum, 
                             Fw::Success& condition     
                             ) override;

    void run_handler(const FwIndexType portNum, 
                     U32 context                
                     ) override;

    void runInternal_internalInterfaceHandler() override;

    void runInternal_overflowHook() override;

    void dataReturnIn_handler(FwIndexType portNum,  
                              Fw::Buffer& data,
                              const ComCfg::FrameContext& context) override;

    // ----------------------------------------------------------------------
    // Hook implementations for typed async input ports
    // ----------------------------------------------------------------------

    void comPacketQueueIn_overflowHook(FwIndexType portNum, Fw::ComBuffer& data, U32 context) override;

    void bufferQueueIn_overflowHook(FwIndexType portNum,  
                                    Fw::Buffer& fwBuffer  
                                    ) override;

    // ----------------------------------------------------------------------
    // Helper Functions
    // ----------------------------------------------------------------------

    bool enqueue(const FwIndexType queueNum,  
                 const Fw::ComBuffer& data    
    );

    bool enqueue(const FwIndexType queueNum,  
                 const Fw::Buffer& data       
    );

    bool handleEnqueueStatus(const FwIndexType queueNum,       
                             QueueType queueType,              
                             const FwIndexType portNum,        
                             const bool preEmptiveOverflow,    
                             const Fw::SerializeStatus status  
    );

    void sendComBuffer(Fw::ComBuffer& comBuffer,  
                       FwIndexType queueIndex     
    );

    void sendBuffer(Fw::Buffer& buffer,     
                    FwIndexType queueIndex  
    );

    void drainQueue(FwIndexType queueNum  
    );

    void processQueue();

    FwIndexType getQueueNum(Svc::QueueType queueType, FwIndexType portNum);

    FwSizeType getQueueDepth(const FwIndexType queueNum  
    ) const;

  private:
    // ----------------------------------------------------------------------
    // Member variables
    // ----------------------------------------------------------------------
    Fw::ComBuffer m_dequeued_com_buffer;                     
    Types::Queue m_queues[TOTAL_PORT_COUNT];                 
    QueueMetadata m_prioritizedList[TOTAL_PORT_COUNT];       
    std::atomic<U32> m_comIngressDrops[COM_PORT_COUNT];      
    std::atomic<U32> m_buffIngressDrops[BUFFER_PORT_COUNT];  
    U32 m_managedDrops[TOTAL_PORT_COUNT];     
    bool m_throttle[TOTAL_PORT_COUNT];        
    SendState m_state;                        
    std::atomic<BufferState> m_buffer_state;  
    std::atomic<bool> m_runQueued;            

    // Storage for Fw::MemAllocator properties
    FwEnumStoreType m_allocationId;  
    Fw::MemAllocator* m_allocator;   
    void* m_allocation;              
};

}  // end namespace Svc

#endif