Qxtrm_test_server.cpp

Go to the documentation of this file.

// Qxtrm_test_server.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "Poco/Util/Application.h"
#include "Poco/Util/ServerApplication.h"
#include "Poco/String.h"
#include "Poco/Environment.h"
#include "Poco/Format.h"

#include "../Qxtrm_driver/Qxtrm_driver.h"
#include "../newicp/icptimer.h"

class MyServerApp : public Poco::Util::ServerApplication
{
    virtual int main(const std::vector<std::string>& args);
};

int MyServerApp::main(const std::vector<std::string>& args)
{
        if (config().getBool("application.runAsService", false))
        {
                // we are a windows service
        }
        std::cerr << "press a key";
        getc(stdin);
        try
        {
                std::string app_dir = config().getString("application.dir");
                std::string config_file = app_dir + "..\\..\\..\\qxtrm_config.xml";
                if ( access(config_file.c_str(), 04) == -1 )
                {
                        config_file = app_dir + "qxtrm_config.xml";
                }
                std::cerr << "Using config file " << config_file << std::endl;
                std::cerr << "Initialising Qxtrm connection ... ";
                int nwords = 25*1024*1024;
#if 1
                Qxtrm_driver qx_driver(config_file, "host", 0, 1, true);
#else
                Qxtrm_driver qx_driver(config_file, "host_loopback", "process1");
                std::cerr << "Creating channel eth1_RDMA1_loop ... ";
                Poco::SharedPtr<Qxtrm_channel> rdma_mem_loop = qx_driver.createChannel("eth1_RDMA1_loop");
                std::cerr << "Creating channel eth1_RDMA2_loop ... ";
                Poco::SharedPtr<Qxtrm_channel> rdma_reg_loop = qx_driver.createChannel("eth1_RDMA2_loop");
                uint32_t* local_mem = new uint32_t[nwords]; 
                uint32_t* local_reg = new uint32_t[nwords]; 
                rdma_mem_loop->RDMARegisterMemory(local_mem, nwords * 4, 0x0);
                rdma_reg_loop->RDMARegisterMemory(local_reg, nwords * 4, 0x0);
#endif
                std::cerr << "DONE" << std::endl;
                std::cerr << "Creating channel eth1_RDMA1 ... ";
                Poco::SharedPtr<Qxtrm_channel> rdma_mem = qx_driver.createChannel("eth1_RDMA1");
                std::cerr << "DONE" << std::endl;
                std::cerr << "Creating channel eth1_RDMA2 ... ";
                Poco::SharedPtr<Qxtrm_channel> rdma_reg = qx_driver.createChannel("eth1_RDMA2");
                std::cerr << "DONE" << std::endl;
                // reset interface
//              rdma_reg->RDMAWrite(1, 0x00030010);
//              rdma_reg->RDMAWrite(1, 0x00030014);
//              rdma_reg->RDMAWrite(1, 0x00030018);
//              rdma_reg->RDMAWrite(1, 0x0003001C);
                uint32_t raw_frames;
//              rdma_reg->RDMARead(raw_frames, 0x0);
//              std::cerr << "reg "  << local_reg[0x00000230 / 4] << std::endl;

                rdma_reg->RDMAWrite(53, 0x00000230);
//              std::cerr << "reg "  << local_reg[0x00000230 / 4] << std::endl;
                char* mem_buffer = new char[nwords * 4];
//              ICPTimer tim("READ tests");
//              rdma_mem->RDMARead(mem_buffer, nbytes, 0x0);
//              tim.info("100Mb", std::cerr);
                ICPTimer tim("WRITE tests");
                rdma_mem->RDMAWrite(mem_buffer, nwords * 4, 0x0);
                tim.info("100Mb", std::cerr);
                qx_driver.channelStatus(std::cerr);
                qx_driver.channelTransferStats(std::cerr);
                delete[] mem_buffer;
//              waitForTerminationRequest();
        }
        catch(const std::exception& ex)
        {
                std::cerr << ex.what() << std::endl;
        }
        return EXIT_OK;
}

int _tmain(int argc, _TCHAR* argv[])
{
        MyServerApp app;
        return app.run(argc, argv);
}