modularization/src1/common/modulecomm/main.cpp

#include <QCoreApplication>

#include <thread>
#include <chrono>
#include <iostream>

#include "modulecomm.h"

#include "modulecommext.h"

#include <QSharedMemory>

#include "testmodulecommext.pb.h"


void * gpa;

std::chrono::time_point<std::chrono::steady_clock, std::chrono::duration<double,std::nano>> t1,t2;

void testcall(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
{
    qint64 sendtime;
    t2 = std::chrono::steady_clock::now();
    double dr_ns = std::chrono::duration<double,std::nano>(t2-t1).count();
    memcpy(&sendtime,strdata,8);
    qDebug("lat is %d ns is %f ",QDateTime::currentMSecsSinceEpoch() - sendtime,dr_ns);
}

void threadsend()
{
    char * strdata = new char[3000000];
    while(1)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        qint64 ntime = QDateTime::currentMSecsSinceEpoch();
        memcpy(strdata,&ntime,8);

        iv::modulecomm::ModuleSendMsg(gpa,strdata,2000000);
        t1 =  std::chrono::steady_clock::now();
        qDebug("send msg.");
    }
}

void testcall2(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
{
    qint64 sendtime;
    t2 = std::chrono::steady_clock::now();
    double dr_ns = std::chrono::duration<double,std::nano>(t2-t1).count();
    memcpy(&sendtime,strdata,8);
    qDebug("lat is %d ns is %f ",QDateTime::currentMSecsSinceEpoch() - sendtime,dr_ns);
}

void threadsend2()
{
    char * strdata = new char[3000000];
    int nsendlen = 10000;
    while(1)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        qint64 ntime = QDateTime::currentMSecsSinceEpoch();
        memcpy(strdata,&ntime,8);
        if(nsendlen<2000000)nsendlen = nsendlen*1001/1000;
        iv::modulecomm::ModuleSendMsg(gpa,strdata,nsendlen);
        t1 =  std::chrono::steady_clock::now();
//        qDebug("send msg.");
    }
}

#include <future>


void testfunc(int a)
{
    a = a+1;
    std::cout<<"a = "<<a<<std::endl;

}

void testfunc2(double a)
{
    a = a+1.1;
    std::cout<<"a = "<<a<<std::endl;

}


iv::modulecommext::modulecommmsg<iv::testmodulecommext> * gmsgtestsend,* gmsgtestrecv;


void ListenProto(google::protobuf::Message & xmsg)
{
    iv::testmodulecommext * pmsg = (iv::testmodulecommext *)&xmsg;
    qDebug("time : %lld",pmsg->time());
}

void threadsendproto()
{
    while(1)
    {
        iv::testmodulecommext xmsg;
        xmsg.set_a(1);
        xmsg.set_b(2);
        xmsg.set_time(QDateTime::currentMSecsSinceEpoch());
        gmsgtestsend->ModuleSendMsg(xmsg);
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

//    auto x1 =  std::chrono::system_clock::now();
//    std::cout << "秒:"<<std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count() << std::endl;
//        std::cout << "毫秒:" << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count()<<std::endl;
//        std::cout << "微秒:" << std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch()).count() << std::endl;
//        std::cout << "纳秒:" << std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count() << std::endl;
//        qint64 naotime = std::chrono::system_clock::now().time_since_epoch().count();

//    int j;
//    for(j=0;j<10000000;j++)
//    {

//    }
//    auto x2 = std::chrono::system_clock::now();
//    double elapsed =
//        std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now() - x1).count();

//    qDebug("ela is %f ",elapsed);
//    return 0;



//    gpa = iv::modulecomm::RegisterSend("test1",3000000,1,iv::modulecomm::ModuleComm_INTERIOR);
//    iv::modulecomm::RegisterRecv("test1",testcall,iv::modulecomm::ModuleComm_INTERIOR);
//    std::thread * xthread = new std::thread(threadsend);


//    QSharedMemory * pmem = new QSharedMemory("hello");
//    pmem->create(1000);
//    qDebug("create");
//    pmem->lock();
//    qDebug("lock");
//    gpa = iv::modulecomm::RegisterSend("test1",1000,1);
//    gpa = iv::modulecomm::RegisterSend("test1");
//    iv::modulecomm::RegisterRecv("test1",testcall2);
//    gpa = iv::modulecomm::RegisterSend("test1",1000,1,iv::modulecomm::ModuleComm_FASTRTPS);
//    iv::modulecomm::RegisterRecv("test1",testcall2,iv::modulecomm::ModuleComm_FASTRTPS);
//    iv::modulecomm::RegisterRecv("test1",testcall2);
//    std::thread * xthread = new std::thread(threadsend2);


      gmsgtestsend = new iv::modulecommext::modulecommmsg<iv::testmodulecommext>();

      gmsgtestsend->RegisterSend("testsendproto");

      gmsgtestrecv = new iv::modulecommext::modulecommmsg<iv::testmodulecommext>();

      gmsgtestrecv->RegisterRecv("testsendproto",ListenProto);

      std::thread * xthreadproto = new std::thread(threadsendproto);



//    extfunc<int>::pfun x = &testfunc;
//    extfunc<double>::pfun x2 = &testfunc2;
//    (*x)(1);
//    (*x2)(2.0);


    return a.exec();
}