Qxtrm_driver.cpp

Go to the documentation of this file.

// Qxtrm_driver.cpp : Defines the exported functions for the DLL application.
//

#include "stdafx.h"

class WinsockException : public std::runtime_error
{
public:
        explicit WinsockException(const std::string& message) : std::runtime_error(win32_message(message, WSAGetLastError())) { }
        explicit WinsockException(const std::string& message, DWORD code) : std::runtime_error(win32_message(message, code)) { }
private:
        static std::string win32_message(const std::string& message, DWORD code)
        {
                std::string s(message);
                s.append(": ");
        LPTSTR errMsg;
                FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER 
                   | FORMAT_MESSAGE_FROM_SYSTEM 
                   | FORMAT_MESSAGE_IGNORE_INSERTS,
                  NULL,
                  code,
                  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                  (LPTSTR) &errMsg,
                  0,
                  NULL);
                s.append(errMsg);
        LocalFree((LPVOID)errMsg);
                return s;
        }
};

#include "qxtrm.h"
#include "Qxtrm_driver.h"

#include "Poco/String.h"
#include "Poco/Environment.h"
#include "Poco/Format.h"

Qxtrm_channel::Qxtrm_channel(Poco::SharedPtr<Quixtream> qx, const std::string& chan_name) : ISIS::Base("Qxtrm_channel"), m_qx(qx), m_chan_name(chan_name), m_chan_id(INVALID_QXTRM_CHANNEL)
{
        setLoggerName("Qxtrm_channel");
        LOGSTR_INFORMATION("Creating channel \"" << chan_name << "\"");
        m_chan_id = qx->GetChannel(const_cast<char*>(m_chan_name.c_str()));
        if ( INVALID_QXTRM_CHANNEL == m_chan_id )
        {
                throw qxtrmException(std::string("Qxtrm_channel: error mapping channel ") + m_chan_name);
        }
}

Qxtrm_channel::~Qxtrm_channel()
{
}

void Qxtrm_channel::RDMARead(void* buffer, unsigned int len, unsigned int remote_address)
{
        int timeout = 5 * 1000; /* QXTRM_WAIT_FOREVER */
        LOGSTR_INFORMATION("RDMARead channel \"" << m_chan_name << "\" address " << std::hex << "0x" << remote_address << std::dec << " count " << len);
        qxtrmStatus status = m_qx->RDMARead(m_chan_id, static_cast<char*>(buffer), len, remote_address, qxtrmTransferSync, timeout);
        if (qxtrmStatusOK != status)
        {
                throw qxtrmException(status, "Qxtrm_channel::RDMARead failed", m_qx, m_chan_id);
        }
}

void Qxtrm_channel::RDMAWrite(const void* buffer, unsigned int len, unsigned int remote_address)
{
        int timeout = 5 * 1000; /* QXTRM_WAIT_FOREVER */
        LOGSTR_INFORMATION("RDMAWrite channel \"" << m_chan_name << "\" address " << std::hex << "0x" << remote_address << std::dec << " count " << len);
        qxtrmStatus status = m_qx->RDMAWrite(m_chan_id, static_cast<char*>(const_cast<void*>(buffer)), len, remote_address, qxtrmTransferSync, timeout);
        if (qxtrmStatusOK != status)
        {
                throw qxtrmException(status, "Qxtrm_channel::RDMAWrite failed", m_qx, m_chan_id);
        }
}


std::string Qxtrm_channel::channelStatus() const
{
        qxtrmChannelStatus chan_stat;
        qxtrmStatus status = (const_cast<Poco::SharedPtr<Quixtream>&>(m_qx))->GetTransferStats(m_chan_id, qxtrmTransStatsCmdLastStatus, &chan_stat);
        if (qxtrmStatusOK == status)
        {
                return Qxtrm_driver::qxtrmChannelStatusMessage(chan_stat);
        }
        else
        {
//              throw qxtrmException(status, "Qxtrm_channel::channelStatus failed");
                return Qxtrm_driver::qxtrmStatusMessage(status);
        }
}

void Qxtrm_channel::channelStatsHelper(int chan, qxtrmTransStatsCmd cmd, const char* mess, std::ostream& os) const
{
        unsigned int n = 0;
        qxtrmStatus status = (const_cast<Poco::SharedPtr<Quixtream>&>(m_qx))->GetTransferStats(chan, cmd, &n);
        if (qxtrmStatusOK == status)
        {
                os << mess << ": " << n << "\n";
        }
        else
        {
                os << mess << ": unknown (" << Qxtrm_driver::qxtrmStatusMessage(status) << ")\n";
        }
}

std::ostream& Qxtrm_channel::channelTransferStats(std::ostream& os) const
{
        os << "--- Transfer stats for channel \"" << m_chan_name << "\" (id=" << m_chan_id << ") ---\n";
        channelStatsHelper(m_chan_id, qxtrmTransStatsCmdLastBytesTrans, "Bytes transferred for last completed transfer", os);
        channelStatsHelper(m_chan_id, qxtrmTransStatsCmdTotalBytesTrans, "Bytes transferred for all cumulative transfers", os);
        channelStatsHelper(m_chan_id, qxtrmTransStatsCmdLastDataErrors, "Data frame errors for last completed transfer", os);
        channelStatsHelper(m_chan_id, qxtrmTransStatsCmdTotalDataErrors, "Data frame errors for all cumulative transfers", os);
        channelStatsHelper(m_chan_id, qxtrmTransStatsCmdLastAckErrors, "Acknowledgement frame errors for last completed transfer", os);
        channelStatsHelper(m_chan_id, qxtrmTransStatsCmdTotalAckErrors, "Acknowledgement frame errors for all cumulative transfers", os);       
        return os;
}

std::ostream& Qxtrm_channel::channelStatus(std::ostream& os) const
{
        os << "Channel \"" << m_chan_name << "\" (id=" << m_chan_id << "): " <<  channelStatus();
        return os;
}


void Qxtrm_channel::blockSend(const void* buffer, unsigned int len)
{
        LOGSTR_INFORMATION("blockSend channel \"" << m_chan_name << "\" count " << len);
        int timeout = 5 * 1000; /* QXTRM_WAIT_FOREVER */
        qxtrmStatus status = m_qx->BlockSend(m_chan_id, static_cast<char*>(const_cast<void*>(buffer)), len, qxtrmTransferSync, timeout);
        if (status != qxtrmStatusOK)
        {
                throw qxtrmException(status, "Qxtrm_channel::blockSend failed", m_qx, m_chan_id);
        }
}

void Qxtrm_channel::blockReceive(void* buffer, unsigned int len)
{
        LOGSTR_INFORMATION("blockReceive channel \"" << m_chan_name << "\" count " << len);
        int timeout = 5 * 1000; /* QXTRM_WAIT_FOREVER */
        qxtrmStatus status = m_qx->BlockRecv(m_chan_id, static_cast<char*>(buffer), len, qxtrmTransferSync, timeout);
        if (status != qxtrmStatusOK)
        {
                throw qxtrmException(status, "Qxtrm_channel::blockReceive failed", m_qx, m_chan_id);
        }
}


void Qxtrm_channel::streamSend(const void* buffer, unsigned int len)
{
        int timeout = 5 * 1000; /* QXTRM_WAIT_FOREVER */
        char* pDataBuffer = NULL;
        LOGSTR_INFORMATION("streamSend channel \"" << m_chan_name << "\" count " << len);
        qxtrmStatus status = m_qx->StreamSend(m_chan_id, &pDataBuffer, timeout); // acquire segment buffer
        if (status != qxtrmStatusOK)
        {
                throw qxtrmException(status, "Qxtrm_channel::streamSend(1) failed", m_qx, m_chan_id);
        }
        memcpy(pDataBuffer, buffer, len); 
        status = m_qx->StreamSend(m_chan_id, len, true); // send data and signal end of segment
        if (status != qxtrmStatusOK)
        {
                throw qxtrmException(status, "Qxtrm_channel::streamSend(2) failed", m_qx, m_chan_id);
        }
}

void Qxtrm_channel::streamReceive()
{
        int timeout = QXTRM_WAIT_FOREVER;
    char *pData = NULL;
    unsigned int newDataAvail = 0;
    unsigned int oldDataAvail = 0;
    bool endOfSeg = false;
        LOGSTR_INFORMATION("streamReceive channel \"" << m_chan_name);
        qxtrmStatus status; 
        while(!endOfSeg)
        {
            status = m_qx->StreamRecv(m_chan_id, &pData, &newDataAvail, &endOfSeg, qxtrmTransferAsync, timeout);
                if (status != qxtrmStatusOK && status != qxtrmStatusNoStreamDataWaiting)
                {
                        throw qxtrmException(status, "Qxtrm_channel::streamReceive(StreamRecv) failed", m_qx, m_chan_id);
                }
                if (newDataAvail > oldDataAvail)
                {
                        outputStreamDataCallback(pData, newDataAvail, endOfSeg);
                        oldDataAvail = newDataAvail;
                }
                else
                {
                        std::cerr << "Qxtrm_channel::streamReceive(StreamRecv) waiting for more data, sofar " << oldDataAvail << std::endl;
                    Sleep(1000);
                }
        }
        status = m_qx->TransferSync(m_chan_id);
        if (status != qxtrmStatusOK)
        {
                throw qxtrmException(status, "Qxtrm_channel::streamReceive(TransferSync) failed", m_qx, m_chan_id);
        }
        status = m_qx->StreamReleaseSegment(m_chan_id);
        if (status != qxtrmStatusOK)
        {
//              std::cerr << "Qxtrm_channel::streamReceive(StreamReleaseSegment) failed: " << Qxtrm_driver::qxtrmStatusMessage(status, m_qx, m_chan_id) << std::endl;
                throw qxtrmException(status, "Qxtrm_channel::streamReceive(StreamReleaseSegment) failed", m_qx, m_chan_id);
        }
        oldDataAvail = 0;
}


void Qxtrm_channel::streamReceive(qxtrmStreamCallbackFunc pCallback, unsigned int interval)
{
        int timeout = 5 * 1000; /* QXTRM_WAIT_FOREVER */
        LOGSTR_INFORMATION("streamReceive channel \"" << m_chan_name << "\" interval " << interval);
        qxtrmStatus status; 
        while( (status = m_qx->StreamRecv(m_chan_id, pCallback, interval, qxtrmTransferSync, timeout)) == qxtrmStatusTransferTimeout )
        {
                std::cerr << "Qxtrm_channel::streamReceive(StreamRecv) timeout, retrying" << std::endl;
        }
        if (status != qxtrmStatusOK)
        {
                throw qxtrmException(status, "Qxtrm_channel::streamReceive(StreamRecv) failed", m_qx, m_chan_id);
        }
        std::cerr << "releasing stream" << std::endl;
        status = m_qx->StreamReleaseSegment(m_chan_id);
        if (status != qxtrmStatusOK)
        {
//              std::cerr << "Qxtrm_channel::streamReceive(StreamReleaseSegment) failed: " << Qxtrm_driver::qxtrmStatusMessage(status, m_qx, m_chan_id) << std::endl;
                throw qxtrmException(status, "Qxtrm_channel::streamReceive(StreamReleaseSegment) failed", m_qx, m_chan_id);
        }
}

void Qxtrm_channel::outputStreamDataCallback(char* pDataBuffer, unsigned int callbackSize, bool segmentEnd)
{
        static int oldData = 0; // amount of data read so far
        char* pNewData;
        int newData, word_size = m_outstream_word_size;
        union
        {
                unsigned int u;
                char c[4];
        } word;
        FILE* outstream = (m_outstream != NULL ? m_outstream : stdout);
        pNewData = pDataBuffer + oldData;
        newData = callbackSize - oldData;
        if (!segmentEnd)
        {
                newData = word_size * (newData / word_size); // if we are not segment end, round to a multiple of word size
        }
        std::cerr << "outputStreamDataCallback: callbackSize=" << callbackSize << " oldData=" << oldData << " newData=" << newData << " segmentEnd=" << segmentEnd << std::endl;
        word.u = 0;
        for(int i = 0; i < newData; ++i)
        {
                word.c[i%word_size] = pNewData[i]; // little endian specific filing of union
                ++oldData;
                if ( (i+1) % word_size == 0 )
                {
                fprintf(outstream, "0x%0*x%s", 2*word_size, word.u, ((oldData % (word_size * m_outstream_columns) == 0) ? "\n" : " ")); // words per line
                }
        }
        if (segmentEnd)
        {
            std::cerr << "outputStreamDataCallback: finished segment total size=" << callbackSize << std::endl;
                if (oldData != callbackSize)
                {
                std::cerr << "outputStreamDataCallback: ERROR: callbackSize=" << callbackSize << " oldData=" << oldData << std::endl;
                }
                oldData = 0;
            fprintf(outstream, "\n");
        }
}


void Qxtrm_channel::RDMARegisterMemory(void* local_address, unsigned int len, unsigned int rdmaAddr)
{
        qxtrmStatus status = m_qx->RDMARegisterMemory(m_chan_id, static_cast<char*>(local_address), len, rdmaAddr);
        if (qxtrmStatusOK != status)
        {
                throw qxtrmException(status, "Qxtrm_channel::RDMARegisterMemory failed", m_qx, m_chan_id);
        }
}

void Qxtrm_channel::RDMAUnregisterMemory(unsigned int rdmaAddr)
{
        qxtrmStatus status = m_qx->RDMAUnregisterMemory(m_chan_id, rdmaAddr);
        if (qxtrmStatusOK != status)
        {
                throw qxtrmException(status, "Qxtrm_channel::RDMAUnregisterMemory failed", m_qx, m_chan_id);
        }
}

std::ostream& Qxtrm_driver::channelStatus(std::ostream& os) const
{
        for(chan_map_t::const_iterator it = m_chans.begin(); it != m_chans.end(); ++it)
        {
                it->second->channelStatus(os);
        }
        return os;
}

std::ostream& Qxtrm_driver::channelTransferStats(std::ostream& os) const
{
        for(chan_map_t::const_iterator it = m_chans.begin(); it != m_chans.end(); ++it)
        {
                it->second->channelTransferStats(os);
        }
        return os;
}

void Qxtrm_driver::getNetworkDetails(const std::string& ip_prefix, std::string& ip_addr, std::string& mac_addr)
{
        ULONG outBufLen = 0;
        DWORD dwRetVal = 0;
        char mac_buffer[32];
        ip_addr = mac_addr = "";
        IP_ADAPTER_INFO* pAdapterInfos = (IP_ADAPTER_INFO*) malloc(sizeof(IP_ADAPTER_INFO));

        // retry up to 5 times, to get the adapter infos needed
        for( int i = 0; i < 5 && (dwRetVal == ERROR_BUFFER_OVERFLOW || dwRetVal == NO_ERROR); ++i )
        {
                dwRetVal = GetAdaptersInfo(pAdapterInfos, &outBufLen);
                if( dwRetVal == NO_ERROR )
                {
                        break;
                }
                else if( dwRetVal == ERROR_BUFFER_OVERFLOW )
                {
                        free(pAdapterInfos);
                        pAdapterInfos = (IP_ADAPTER_INFO*) malloc(outBufLen);
                }
                else
                {
                        pAdapterInfos = 0;
                        break;
                }
        }
        if( dwRetVal == NO_ERROR )
        {
                IP_ADAPTER_INFO* pAdapterInfo = pAdapterInfos;
                while( pAdapterInfo )
                {
                        IP_ADDR_STRING* pIpAddress = &(pAdapterInfo->IpAddressList);
                        while( pIpAddress != 0 )
                        {
                                if ( !strncmp(pIpAddress->IpAddress.String, ip_prefix.c_str(), ip_prefix.size()) )
                                {
                                        ip_addr = pIpAddress->IpAddress.String;
                                        sprintf(mac_buffer, "%02X-%02X-%02X-%02X-%02X-%02X", pAdapterInfo->Address[0], pAdapterInfo->Address[1], pAdapterInfo->Address[2], 
                                                                                pAdapterInfo->Address[3], pAdapterInfo->Address[4], pAdapterInfo->Address[5]);
                                        mac_addr = mac_buffer;
                                }
                                pIpAddress = pIpAddress->Next;
                        }
                        pAdapterInfo = pAdapterInfo->Next;
                }
        }
        free(pAdapterInfos);
}

void Qxtrm_driver::loadConfigData(const std::string& config_file, int ethernet_id, bool do_remote_config, std::string& config_data)
{
        std::stringstream config_stream;
        std::string ip_prefix = "192.168.1.";   // must end with a "."
        std::string card_ip, card_mac;
        std::fstream fs(config_file, std::ios::in);
        config_stream << fs.rdbuf();
        fs.close();
        config_data = config_stream.str();
        std::string ip_addr, mac_addr;
        getNetworkDetails(ip_prefix, ip_addr, mac_addr);
        if ( ip_addr.size() == 0 )
        {
                ip_prefix = "192.168.0.";   // This is Kelvin's NDW834 machine
                getNetworkDetails(ip_prefix, ip_addr, mac_addr);   
        }
        if ( ip_addr.size() == 0 )
        {
                ip_prefix = "130.246.49.";  
                getNetworkDetails(ip_prefix, ip_addr, mac_addr);   
        }
        switch(ethernet_id)
        {
                case 0:
                        card_ip = Poco::format("%s%d", ip_prefix, 1);
                        card_mac = "00-0A-35-00-00-00";
                        break;

                case 1:
                        card_ip = Poco::format("%s%d", ip_prefix, 2);
                        card_mac = "00-0A-35-00-00-02";
                        break;

                case 2:
                        card_ip = Poco::format("%s%d", ip_prefix, 3);
                        card_mac = "00-0A-35-00-00-03";
                        break;

                default:
                        throw(std::runtime_error("invalid card ethernet id"));
                        break;
        }
        struct sockaddr_in addr;
        SOCKET sfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        if (sfd < 0) 
        {
                throw WinsockException("socket"); 
        }
        memset(&addr, 0, sizeof(struct sockaddr_in));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(0); // ask to be allocated a port
        addr.sin_addr.S_un.S_addr = inet_addr(ip_addr.c_str());
        if (::bind(sfd, (struct sockaddr*)&addr, sizeof(struct sockaddr_in)) < 0)
        { 
                throw WinsockException("bind"); 
        }
        int namelen = sizeof(struct sockaddr_in);
        if (getsockname(sfd, (struct sockaddr*)&addr, &namelen) < 0) 
        {
                throw WinsockException("getsockname");
        }
        char port_string[10];
        closesocket(sfd);
//      sprintf(port_string, "0x%x", addr.sin_port);
        sprintf(port_string, "0x%x", 0xfe02 + 8 * ethernet_id);
        std::cerr << "Using HOST IP " << ip_addr << " Mac " << mac_addr << " Port " << port_string << std::endl;
        LOGSTR_INFORMATION("Using HOST IP " << ip_addr << " Mac " << mac_addr << " Port " << port_string);
        LOGSTR_INFORMATION("Using FPGA IP " << card_ip << " Mac " << card_mac);
        Poco::replaceInPlace(config_data, "##HOST_IP##", ip_addr.c_str());
        Poco::replaceInPlace(config_data, "##HOST_MAC##", mac_addr.c_str());    // e.g. "00-25-64-B5-92-21"
        Poco::replaceInPlace(config_data, "##HOST_PORT_BASE##", port_string);
        Poco::replaceInPlace(config_data, "##PACKET_SIZE##", "1452");          // 1452 on standard network, 7944 on jumbo frames network
        Poco::replaceInPlace(config_data, "##DAE_CARD##", "DAE_CARD_FPGA");
        Poco::replaceInPlace(config_data, "##DAE_CARD_IP##", card_ip.c_str());
        Poco::replaceInPlace(config_data, "##DAE_CARD_MAC##", card_mac.c_str());  // e.g. "00-0A-35-00-00-00"
        Poco::replaceInPlace(config_data, "##DAE_CARD_PORT_BASE##", "0xfe22");
        Poco::replaceInPlace(config_data, "##ACK_TIMEOUT##", "1000");  // milliseconds
        Poco::replaceInPlace(config_data, "##DATA_TIMEOUT##", "1000"); // milliseconds
        Poco::replaceInPlace(config_data, "##ACK_MODE##", "on"); // On or Off
        if (do_remote_config)
        {
            Poco::replaceInPlace(config_data, "##REMOTE_CONFIG##", "<RemoteConfig remoteinterface=\"Eth0\" remoteprocess=\"process1\" remotenode=\"host\"/>"); 
        }
        else
        {
            Poco::replaceInPlace(config_data, "##REMOTE_CONFIG##", ""); 
        }
        Poco::replaceInPlace(config_data, "##ACK_MODE##", "on"); // On or Off
}

Poco::SharedPtr<Qxtrm_channel> Qxtrm_driver::createChannel(const std::string& chan_name)
{
        Poco::SharedPtr<Qxtrm_channel> chan = new Qxtrm_channel(m_qx, chan_name);
        m_chans[chan_name] = chan;
        return chan;
}


std::string Qxtrm_driver::qxtrmStatusMessage(int qxtrm_status, Quixtream* qx, int chan)
{
        std::string message;
        switch(qxtrm_status)
        {
        case qxtrmStatusOK:
                message = "The command completed successfully with no errors.";
                break;

        case qxtrmStatusInvalidChannelHandle:
                message = "The supplied channel handle is not valid. ";
                break;

        case qxtrmStatusInvalidTransferForChannel:
                message = "The requested transfer type is not supported by this channel instance. ";
                break;

        case qxtrmStatusChannelTerminated:
                message = "The channels transfer thread is not running. ";
                break;

        case qxtrmStatusTransferInProgress:
                message = "The channel instance already has a transfer in progress, or has an unsynced completed transfer. ";
                break;

        case qxtrmStatusInvalidTransferArguments:
                message = "The transfer arguments are invalid, i.e. the sizes may not be aligned, etc. ";
                break;

        case qxtrmStatusTransferTimeout:
                message = "The timeout period on this channel expired before the transfer commenced. ";
                break;

        case qxtrmStatusTransferErrors:
                message = "The last transfer on this channel completed with errors. Use GetTransferStats() to see the nature of the errors. ";
                break;

        case qxtrmStatusTransferNotInProgress:
                message = "The channel instance does not have an outstanding transfer which require syncing. ";
                break;

        case qxtrmStatusNoStreamDataWaiting:
                message = "There is no streaming data waiting to be received on the stream channel. Stream data must be available for an async call. ";
                break;

        case qxtrmStatusNoStreamBuffersFree:
                message = "No free Stream buffers available to write into. ";
                break;

        case qxtrmStatusStreamNotInitialised:
                message = "The Stream send has not been initialised yet. ";
                break;

        case qxtrmStatusRDMARegionOverlap:
                message = "The specified RDMA region overlaps with an existing region. ";
                break;

        case qxtrmStatusTooManyRDMARegions:
                message = "Too many RDMA memory regions already specified. ";
                break;

        case qxtrmStatusError:
                message = "General error. ";
                break;

        default:
                message = Poco::format("Unknown qxtrmStatus error code %d. ", qxtrm_status);
                break;
        }
        if (NULL != qx && INVALID_QXTRM_CHANNEL != chan)
        {
                message += qxtrmChannelStatusMessage(qx, chan);
        }
        return message;
}

std::string Qxtrm_driver::qxtrmChannelStatusMessage(Quixtream* qx, int chan)
{       
        qxtrmChannelStatus chan_stat;
        qxtrmStatus status = qx->GetTransferStats(chan, qxtrmTransStatsCmdLastStatus, &chan_stat);
        if (qxtrmStatusOK == status)
        {
                return "Channel status: " + qxtrmChannelStatusMessage(chan_stat);
        }
        else
        {
                return "GetTransferStats() failed: " + qxtrmStatusMessage(status);
        }
}

std::string Qxtrm_driver::qxtrmChannelStatusMessage(int qxtrm_channel_status)
{
        std::string message;
        switch(qxtrm_channel_status)
        {
        case qxtrmChanStatusOK:
                message = "Transfer completed OK. ";
                break;

        case qxtrmChanStatusInitialPSNMismatch:
                message = "Transfer completed OK, but the initial packet sequence number was not what we expected. This may indicate a sync loss or a whole previous packet loss. ";
                break;

        case qxtrmChanStatusTooMuchData:
                message = "Transfer completed OK. Too much data received compared to the amount expected. ";
                break;

        case qxtrmChanStatusTooLittleData:
                message = "Transfer completed OK. Too little data received compared to the amount expected. ";
                break;

        case qxtrmChanStatusLostDataPackets:
                message = "Transfer failed. Packet seqnece numbers within the message where inconsistent. One or more packets where not received. ";
                break;

        case qxtrmChanStatusLostACKPackets:
                message = "Transfer failed. Packet seqnece numbers within the acknowledgment packets where inconsistent. One or more ACK packets where not received. ";
                break;

        case qxtrmChanStatusACKRecvTimeout:
                message = "Transfer failed. Acknowledgment packet not received before timeout. ";
                break;

        case qxtrmChanStatusDataRecvTimeout:
                message = "Transfer failed. Data packet not received before timeout. ";
                break;

        case qxtrmChanStatusInvalidRDMAAddr:
                message = "Transfer failed. The specified RDMA region was invalid. ";
                break;

        case qxtrmChanStatusTransportFailure:
                message = "Transfer failed. Send or receive command failed. ";
                break;

        default:
                message = Poco::format("Unknown qxtrmChannelStatus error code %d. ", qxtrm_channel_status);
                break;
        }
        return message;
}

Qxtrm_driver::Qxtrm_driver(const std::string& config_file, const std::string& node_name, int ethernet_id, int process_number, bool do_remote_config) : ISIS::Base("Qxtrm_driver"), m_qx(NULL)
{
        setLoggerName("Qxtrm_driver");
        LOGSTR_INFORMATION("Creating Qxtrm driver from \"" << config_file << "\" node \"" << node_name << "\" process \"process" << process_number << "\"");
        int timeout = 30 * 1000;  // in milliseconds, or QXTRM_WAIT_FOREVER
        std::string config_data;
        std::string process_name = Poco::format("process%d", process_number);
        loadConfigData(config_file, ethernet_id, do_remote_config, config_data);
        m_qx = new Quixtream(const_cast<char*>(node_name.c_str()),  const_cast<char*>(process_name.c_str()), 
                                                        const_cast<char*>(config_data.c_str()), false, timeout);
}

Qxtrm_driver::~Qxtrm_driver()
{
}

FILE* Qxtrm_channel::m_outstream = NULL;
int Qxtrm_channel::m_outstream_word_size = 4;
int Qxtrm_channel::m_outstream_columns = 10;