Boost.Asio: Why the timer is executed only once?

Question

I have a function called read_packet. This function remains blocked while there is no connection request or the timer is signaled.

The code is the following:

    std::size_t read_packet(const std::chrono::milliseconds& timeout,
                            boost::system::error_code& error)
    {
      // m_timer_ --> boost::asio::high_resolution_timer

      if(!m_is_first_time_) {
        m_is_first_time = true;

        // Set an expiry time relative to now.
        m_timer_.expires_from_now( timeout );
      } else {
        m_timer_.expires_at( m_timer_.expires_at() + timeout );
      }

      // Start an asynchronous wait.
      m_timer_.async_wait(
          [ this ](const boost::system::error_code& error){
            if(!error) m_is_timeout_signaled_ = true;
          }
      );

      auto result = m_io_service_.run_one();

      if( !m_is_timeout_signaled_ ) {
        m_timer_.cancel();
      }

      m_io_service_.reset();

      return result;
    }

The function works correctly while not receiving a connection request. All acceptances of requests are asynchronous.

After accepting a connection, the run_one() function does not remains blocked the time set by the timer. The function always returns 1 (one handle has been processed). This handle corresponds to the timer.

I do not understand why this situation occurs.

Why the function is not blocked the time required for the timer?

Cheers.

NOTE: This function is used in a loop.

UPDATE:

I have my own io_service::run() function. This function performs other actions and tasks. I want to listen and process the network level for a period of time:

• If something comes on the network level, io_service::run_one() returns and read_packet() returns the control to my run() function.

• Otherwise, the timer is fired and read_packet() returns the control to my run() function.

Everything that comes from the network level is stored in a data structure. Then my run() function operates on that data structure. It also runs other options.

    void run(duration timeout, boost::system::error_code& error)
    {
      time_point start = clock_type::now();
      time_point deadline = start + timeout;

        while( !stop() ) {
          read_packet(timeout, error);
          if(error) return;

          if(is_timeout_expired( start, deadline, timeout )) return;

          // processing network level

          // other actions
        }
    }

In my case, the sockets are always active until a client requests the closing of the connection.

During a time slot, you manage the network level and for another slot you do other things.

Answer 1

After reading the question more closely I got the idea that you are actually trying to use Asio to get synchronous IO, but with a timeout on each read operation.

That's not what Asio was intended for (hence, the name "Asynchronous IO Library").

But sure, you can do it if you insist. Like I said, I feel you're overcomplicating things.

In the completion handler of your timer, just cancel the socket operation if the timer had expired. (Note that if it didn't, you'll get operation_aborted, so check the error code).

Small selfcontained example (which is what you should always do when trying to get help, by the way):

Live On Coliru

#include <boost/asio.hpp>
#include <boost/asio/high_resolution_timer.hpp>
#include <iostream>

struct Program {

    Program() { sock_.connect({ boost::asio::ip::address_v4{}, 6771 }); }

    std::size_t read_packet(const std::chrono::milliseconds &timeout, boost::system::error_code &error) {
        m_io_service_.reset();

        boost::asio::high_resolution_timer timer { m_io_service_, timeout };

        timer.async_wait([&](boost::system::error_code) { 
                sock_.cancel();
            });

        size_t transferred = 0;
        boost::asio::async_read(sock_, boost::asio::buffer(buffer_), [&](boost::system::error_code ec, size_t tx) {
                    error       = ec;
                    transferred = tx;
                });

        m_io_service_.run();

        return transferred;
    }

  private:
    boost::asio::io_service m_io_service_;
    using tcp = boost::asio::ip::tcp;

    tcp::socket sock_{ m_io_service_ };
    std::array<char, 512> buffer_;
};

int main() {
    Program client;
    boost::system::error_code ec;

    while (!ec) {
        client.read_packet(std::chrono::milliseconds(100), ec);
    }

    std::cout << "Exited with '" << ec.message() << "'\n"; // operation canceled in case of timeout
}

If the socket operation succeeds you can see e.g.:

Exited with 'End of file'

Otherwise, if the operation didn't complete within 100 milliseconds, it will print:

Exited with 'Operation canceled'

---

See also await_operation in this previous answer, which generalizes this pattern a bit more:

• boost::asio + std::future - Access violation after closing socket

Answer 2

Ok, The code is incorrect. When the timer is canceled, the timer handler is always executed. For this reason io_service::run_one() function is never blocked.

More information: basic_waitable_timer::cancel

Thanks for the help.