Qxtrm_driver.h

Go to the documentation of this file.

// The following ifdef block is the standard way of creating macros which make exporting 
// from a DLL simpler. All files within this DLL are compiled with the QXTRM_DRIVER_EXPORTS
// symbol defined on the command line. This symbol should not be defined on any project
// that uses this DLL. This way any other project whose source files include this file see 
// QXTRM_DRIVER_API functions as being imported from a DLL, whereas this DLL sees symbols
// defined with this macro as being exported.
#ifndef QXTRM_DRIVER_H
#define QXTRM_DRIVER_H

#ifdef QXTRM_DRIVER_EXPORTS
#define QXTRM_DRIVER_API __declspec(dllexport)
#else
#define QXTRM_DRIVER_API __declspec(dllimport)
#endif

#include "Poco/SharedPtr.h"
#include "../newicp/isisbase.h"
#include "qxtrm.h"

static const int INVALID_QXTRM_CHANNEL = -1;

class Quixtream;

class QXTRM_DRIVER_API Qxtrm_channel : public ISIS::Base
{
        Poco::SharedPtr<Quixtream> m_qx;
        int m_chan_id;
        std::string m_chan_name;
        void channelStatsHelper(int chan, qxtrmTransStatsCmd cmd, const char* mess, std::ostream& oss) const;
        public:
    Qxtrm_channel(Poco::SharedPtr<Quixtream> qx, const std::string& chan_name);
    virtual ~Qxtrm_channel();
        void RDMAWrite(uint32_t value, unsigned int remote_address) { RDMAWrite(&value, sizeof(value), remote_address); }
        void RDMARead(uint32_t& value, unsigned int remote_address) { RDMARead(&value, sizeof(value), remote_address); }
        void RDMARead(void* buffer, unsigned int len, unsigned int remote_address);
        void RDMAWrite(const void* buffer, unsigned int len, unsigned int remote_address);
        void blockSend(const void* buffer, unsigned int len);
        void blockReceive(void* buffer, unsigned int len);
        void streamSend(const void* buffer, unsigned int len);
        void streamReceive(qxtrmStreamCallbackFunc pCallback, unsigned int interval);
        void streamReceive();
        void RDMARegisterMemory(void* local_address, unsigned int len, unsigned int rdmaAddr);
        void RDMAUnregisterMemory(unsigned int rdmaAddr);
        std::string channelStatus() const;
        std::ostream& channelTransferStats(std::ostream& os) const;
        std::ostream& channelStatus(std::ostream& os) const;
        static void outputStreamDataCallback(char* pDataBuffer, unsigned int callbackSize, bool segmentEnd);
        static FILE* m_outstream;
        static int m_outstream_word_size;
        static int m_outstream_columns;
};

// This class is exported from the Qxtrm_driver.dll
 class QXTRM_DRIVER_API Qxtrm_driver : public ISIS::Base
{
        private:
                Poco::SharedPtr<Quixtream> m_qx;
                typedef std::map< std::string, Poco::SharedPtr<Qxtrm_channel> > chan_map_t; 
                chan_map_t m_chans;

        public: // functions
                static void getNetworkDetails(const std::string& ip_prefix, std::string& ip_addr, std::string& mac_addr);
                void loadConfigData(const std::string& config_file, int ethernet_id, bool do_remote_config, std::string& config_data);
                static std::string qxtrmStatusMessage(int qxtrm_status, Quixtream* qx = NULL, int chan = INVALID_QXTRM_CHANNEL);
                static std::string qxtrmChannelStatusMessage(int qxtrm_channel_status);
                static std::string qxtrmChannelStatusMessage(Quixtream* qx, int chan);
                std::ostream& channelStatus(std::ostream& os) const;
                std::ostream& channelTransferStats(std::ostream& os) const;
                Poco::SharedPtr<Qxtrm_channel> createChannel(const std::string& chan_name);
                Qxtrm_driver(const std::string& config_file, const std::string& node_name, int ethernet_id, int process_number, bool do_remote_config);
                virtual ~Qxtrm_driver();
};

class QXTRM_DRIVER_API qxtrmException : public std::runtime_error
{
public:
        explicit qxtrmException(const char* message) : std::runtime_error(message) { }  
        explicit qxtrmException(const std::string& message) : std::runtime_error(message) { }  
        explicit qxtrmException(int qxtrm_status, const std::string& message = "", Quixtream* qx = NULL, int chan = INVALID_QXTRM_CHANNEL) : 
                        std::runtime_error(message + "(Quixtream: " + Qxtrm_driver::qxtrmStatusMessage(qxtrm_status, qx, chan) + ")") { }
};

#endif /* QXTRM_DRIVER_H */