Boost: Example needed: for timeout

Question

I am already working long on this without success.

Imagine you have your main function some sort like this:

bool running = true;
int i = 0;
//waitHandler();
while(running)
    i++;

Now I would like to add and call a timer, which sets running to false, when it expires.

void waitHandler(){ 

    boost::asio::io_service timerService;

    //create and bind the timer
    boost::asio::deadline_timer timer(timerService,
    boost::posix_time::milliseconds(2000));
    timer.wait();

    running = true;
    cout<<"WaitHandler triggered"<<endl;
}

Of course this does not work (when u uncomment the comment above), since the timer will block the main thread. What to do, if I would want to have this functionality without blocking the main function.

EDIT:

//transfer some error message
void set_result(boost::system::error_code* a, boost::system::error_code b,deadline_timer &timer)
  {
     a->assign(b.value(),b.category());
  } 


 template<class SOCKET>
 void read_with_timeout(SOCKET & sock, unsigned int delay,
     const asio::mutable_buffers_1& buffers)
  {       
      //create error messages
      boost::system::error_code timer_result; 
      boost::system::error_code read_result; 

      //initialize timer
      deadline_timer timer(sock.get_io_service());        
      timer.expires_from_now(boost::posix_time::milliseconds(delay));
      timer.async_wait(boost::bind(set_result, &timer_result, _1,boost::ref(timer)));       

      //initialize receive mechanism
      sock.async_receive(buffers, boost::bind(set_result, &read_result, _1,boost::ref(timer)));    
      sock.get_io_service().reset();

      //should run for one handler
      while (sock.get_io_service().run_one())    
      {      
          if (read_result.value()==0){ //zero stands for, that the message was received properly.            
              timer.cancel();
              //cout<<"Message received: => Timer cancelled => RETURN!"<<endl;
              return;
          }

          if(timer.expires_from_now().total_milliseconds() <=0){                
              sock.cancel();                
              //cout<<"Timeout => Socket cancelled => RETURN!"<<endl;         
              return;
          }
      }   
 } 

As said this almost shows the wished behavior, but there are some questions to it:

1. Why by even using run_one, both the handler for the timer and the one for the receive can be fired
2. Why does receive also fire, when 0 bytes are received. For me that sounds like nothing is received and the function is supposed to wait?
3. Is this the right way to do it - as I said I want to receive or timeout. (like pinging)

Actually the pakets are received in wrong order as they appeared in Wireshark - I guess it has something to do with async_receive, which does not really wait for a incoming message, but just takes what is in the buffer before the function call.

What to do?

Answer 1

You are making this much more complex than it needs to be. There are piles of questions on this site dealing with timeouts, and a fantastic example on the Boost.Asio website. The comment from the async_tcp_client example has an excellent ASCII diagram explaining this scenario

// This class manages socket timeouts by applying the concept of a deadline.
// Some asynchronous operations are given deadlines by which they must complete.
// Deadlines are enforced by an "actor" that persists for the lifetime of the
// client object:
//
//  +----------------+
//  |                |
//  | check_deadline |<---+
//  |                |    |
//  +----------------+    | async_wait()
//              |         |
//              +---------+
//
// If the deadline actor determines that the deadline has expired, the socket
// is closed and any outstanding operations are consequently cancelled.
//
// Connection establishment involves trying each endpoint in turn until a
// connection is successful, or the available endpoints are exhausted. If the
// deadline actor closes the socket, the connect actor is woken up and moves to
// the next endpoint.
//
//  +---------------+
//  |               |
//  | start_connect |<---+
//  |               |    |
//  +---------------+    |
//           |           |
//  async_-  |    +----------------+
// connect() |    |                |
//           +--->| handle_connect |
//                |                |
//                +----------------+
//                          :
// Once a connection is     :
// made, the connect        :
// actor forks in two -     :
//                          :
// an actor for reading     :       and an actor for
// inbound messages:        :       sending heartbeats:
//                          :
//  +------------+          :          +-------------+
//  |            |<- - - - -+- - - - ->|             |
//  | start_read |                     | start_write |<---+
//  |            |<---+                |             |    |
//  +------------+    |                +-------------+    | async_wait()
//          |         |                        |          |
//  async_- |    +-------------+       async_- |    +--------------+
//   read_- |    |             |       write() |    |              |
//  until() +--->| handle_read |               +--->| handle_write |
//               |             |                    |              |
//               +-------------+                    +--------------+
//
// The input actor reads messages from the socket, where messages are delimited
// by the newline character. The deadline for a complete message is 30 seconds.
//
// The heartbeat actor sends a heartbeat (a message that consists of a single
// newline character) every 10 seconds. In this example, no deadline is applied
// message sending.
//

You should strive to achieve a similar design in your application. There is no need to bumble around by writing a read_with_timeout() function like you have posted in your question. Using async_read(), async_write(), and async_wait() will be enough to give you the desired functionality.

I think part of your confusion arises over threading. Don't think about it, understand the basic concepts first. You will want to use a single thread (the one invoking main()) and a single io_service to start. After that, you can explore more advanced concepts. If you're trying to integrate this code into a larger application, that is a different question entirely.

Studying the proactor design pattern may be helpful to you as well.

Answer 2

You can either execute io_service::run in a separate thread (and somehow synchronize the access to running) or pump the io_service loop manually within your while loop, using run_one()/poll()/poll_one() - whatever is appropriate in your case.

Answer 3

I have found out some sort of solution. I am ok with it even though there are things I do not understand.

//transfer some error message
void set_result(boost::system::error_code* a, boost::system::error_code b,deadline_timer &timer)
  {
     a->assign(b.value(),b.category());
  } 


 template<class SOCKET>
 void read_with_timeout(SOCKET & sock, unsigned int delay,
     const asio::mutable_buffers_1& buffers)
  {       
      //create error messages
      boost::system::error_code timer_result; 
      boost::system::error_code read_result; 

      //initialize timer
      deadline_timer timer(sock.get_io_service());        
      timer.expires_from_now(boost::posix_time::milliseconds(delay));
      timer.async_wait(boost::bind(set_result, &timer_result, _1,boost::ref(timer)));       

      //initialize receive mechanism
      sock.async_receive(buffers, boost::bind(set_result, &read_result, _1,boost::ref(timer)));    
      sock.get_io_service().reset();

      //should run for one handler
      while (sock.get_io_service().run_one())    
      {      
          if (read_result.value()==0){ //zero stands for, that the message was received properly.            
              timer.cancel();
              //cout<<"Message received: => Timer cancelled => RETURN!"<<endl;
              return;
          }

          if(timer.expires_from_now().total_milliseconds() <=0){                
              sock.cancel();                
              //cout<<"Timeout => Socket cancelled => RETURN!"<<endl;         
              return;
          }
      }   
 } 

This actually works for my case and was taken from http://lists.boost.org/Archives/boost/2007/04/120339.php referenced by this thread: How to set a timeout on blocking sockets in boost asio?

I just adapted it to Boost 1.51.

A few things are still obscured to me like e.g.

• io_service.run_one actually still fires more event handlers even though it is supposed to only fire one.
• Also there are events from the timer which do not at all interest me. I just want to catch the timeout and not other stuff. (I don know why there is other stuff)

In any case my problem was solved so far.

Answer 4

You have to spawn the timer on its own thread and then make sure that you protect the running variable from concurrent access.