Question

Suppose there are several boost strand share_ptr stored in a vector m_poStrands. And tJobType is the enum indicated different type of job.
I found the time diff from posting a job in one strand (JOBA) to call the onJob of another strand (JOBB) is around 50 milli second.
I want to know if there is any way to reduce the time diff.

void postJob(tJobType oType, UINT8* pcBuffer, size_t iSize)
{
//...
    m_poStrands[oType]->post(boost::bind(&onJob, this, oType, pcDestBuffer, iSize));
}

void onJob(tJobType oType, UINT8* pcBuffer, size_t iSize)
{
       if (oType == JOBA)
       {
       //....
         struct timeval sTV;
    gettimeofday(&sTV, 0);
    memcpy(pcDestBuffer, &sTV, sizeof(sTV));
    pcDestBuffer += sizeof(sTV);
    iSize += sizeof(sTV);

    memcpy(pcDestBuffer, pcBuffer, iSize);

         m_poStrands[JOBB]->(boost::bind(&onJob, this, JOBB, pcDestBuffer, iSize));
       }
       else if (oType == JOBB)
       {
        // get the time from buffer
        // and calculate the dime diff
        struct timeval eTV;
        gettimeofday(&eTV, 0);
       }
}

Answer 1

Your latency is probably coming from the memcpys between your gettimeofdays. Here’s an example program I ran on my machine (2 ghz core 2 duo). I’m getting thousands of nanoseconds. So a few microseconds. I doubt that your system is running 4 orders of magnitude slower than mine. The worst I ever saw it run was 100 microsecond for one of the two tests. I tried to make the code as close to the code posted as possible.

#include <boost/asio.hpp>
#include <boost/chrono.hpp>
#include <boost/bind.hpp>
#include <boost/thread.hpp>
#include <iostream>

struct Test {
    boost::shared_ptr<boost::asio::strand>* strands;
    boost::chrono::high_resolution_clock::time_point start;
    int id;

    Test(int i, boost::shared_ptr<boost::asio::strand>* strnds)
        : id(i),
          strands(strnds)
    {
        strands[0]->post(boost::bind(&Test::callback,this,0));
    }

    void callback(int i) {
        if (i == 0) {
          start = boost::chrono::high_resolution_clock::now();
          strands[1]->post(boost::bind(&Test::callback,this,1));
        } else {
          boost::chrono::nanoseconds sec = boost::chrono::high_resolution_clock::now() - start;
          std::cout << "test " << id << " took " << sec.count() << " ns" << std::endl;
        }
    }
};

int main() {
    boost::asio::io_service io_service_;
    boost::shared_ptr<boost::asio::strand> strands[2];
    strands[0] = boost::shared_ptr<boost::asio::strand>(new boost::asio::strand(io_service_));
    strands[1] = boost::shared_ptr<boost::asio::strand>(new boost::asio::strand(io_service_));
    boost::thread t1 (boost::bind(&boost::asio::io_service::run, &io_service_));
    boost::thread t2 (boost::bind(&boost::asio::io_service::run, &io_service_));
    Test test1 (1, strands);
    Test test2 (2, strands);
    t1.join();
    t2.join();
}