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 <limits>
#include "Fw/Types/MemAllocator.hpp"
#include "Os/Mutex.hpp"

namespace Svc {

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

class ComQueue final : public ComQueueComponentBase {
    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;  
    };

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

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

    struct QueueMetadata {
        FwSizeType depth;      
        FwIndexType priority;  
        FwIndexType index;     
        FwSizeType msgSize;    
    };

    enum SendState {
        READY,   
        WAITING  
    };

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

    ComQueue(const char* const compName 
    );

    ~ComQueue();

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

    void cleanup();

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

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

    void FLUSH_ALL_QUEUES_cmdHandler(FwOpcodeType opCode,  
                                     U32 cmdSeq            
                                     ) 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 dataReturnIn_handler(FwIndexType portNum,  
                              Fw::Buffer& data,
                              const ComCfg::FrameContext& context) override;

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

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

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

    bool enqueue(const FwIndexType queueNum,  
                 QueueType queueType,         
                 const U8* data,              
                 const FwSizeType size        
    );

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

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

    void drainQueue(FwIndexType queueNum  
    );

    void processQueue();

  private:
    // ----------------------------------------------------------------------
    // Member variables
    // ----------------------------------------------------------------------
    Fw::ComBuffer m_dequeued_com_buffer;                
    Types::Queue m_queues[TOTAL_PORT_COUNT];            
    QueueMetadata m_prioritizedList[TOTAL_PORT_COUNT];  
    bool m_throttle[TOTAL_PORT_COUNT];                  
    SendState m_state;                                  
    BufferState m_buffer_state;                         

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

}  // end namespace Svc

#endif