Distributed Real-Time Control Systems. Lecture 24 Asynchronous Socket Communications

Transcription

1 Distributed Real-Time Control Systems Lecture 24 Asynchronous Socket Communications with Boost ASIO 1

2 Boost Asynchronous I/O (ASIO) Boost::Asio allows implements a service for asynchronous I/O: boost::asio::io_service The service provides: A thread pool transparent to the user. Asyncronous operation starterswith user completion handlers. Important functions acceptor::async_accept socket::async_connect socket::async_receive_from socket::async_send_to socket::async_write socket::async_read resolver::async_resolve 2

3 Asynchronous UDP Server #include <string> #include <iostream> #include <boost/asio.hpp> #include <boost/array.hpp> #include <boost/bind.hpp> #include <boost/shared_ptr.hpp> using namespace boost::asio; using boost::asio::ip::udp; class udp_server { private: udp::socketsock_; udp::endpoint remote_ep_; boost::array<char, 1> recv_buffer_; void handle_receive(); void handle_send(shared_ptr<std::string> msg); void start_receive(); public: udp_server(io_service& io) : sock_(io, udp::endpoint(udp::v4(), 10000)) { start_receive(); ; void udp_server::start_receive() { sock_.async_receive_from( buffer(recv_buffer_), remote_ep_, boost::bind(&udp_server::handle_receive, this); void udp_server::handle_receive() { boost::shared_ptr<std::string> msg(new std::string( Hello")); sock_.async_send_to(buffer(*msg), remote_ep_, boost::bind(&udp_server::handle_send, this, msg); start_receive(); void udp_server::handle_send(shared_ptr<std::string> msg) { std::cout << "Sent: " << *msg << std::endl; int main() { io_service io; udp_server server(io); io.run(); 3

4 Notes on Asynchronous UDP Server Class udp_server encapsulatedsockets, endpoints, communication buffers and asynchronousoperationhandlers. To invoke class member functions as handlers to asynchronous operations, must use a functor (function object), that associates the member function to the associated object (via a pointer to the object). boost::bind(&udp_server::handle_receive, this); Functors can receive arguments: boost::bind(&udp_server::handle_send, this, msg); 4

5 More about boost::bind boost::bind is an object that encapsulates functions and arguments to be called in the future. bind(f, _2, _1)(x, y); // f(y, x) bind(g, _1, 9, _1)(x); // g(x, 9, x) bind(g, _3, _3, _3)(x, y, z); // g(z, z, z) bind(g, _1, _1, _1)(x, y, z); // g(x, x, x) 5

6 Communication Buffers Lifetime Management Because async_ functions return immediately, we must make sure the communication buffer still exists when the asynchronous operationexecutes. // very bad code... void on_read(const boost::system::error_code & err, std::size_t read_ bytes) {... void func() { char buff[512]; sock.async_receive(buffer(buff), on_read); A poor solution to the problem is to use global variables, but we can do better. 6

7 Raw Buffer Lifetime Management Create a buffer on the heap, pass it to the handler, and destroyitwhen the operationcompletes. void on_read(char * ptr, const boost::system::error_code & err, std::size_t read_bytes) { //do stuff delete[] ptr; //... char * buff = new char[512]; sock.async_receive(buffer(buff, 512), boost::bind(on_ read,buff,_1,_2) ); To pass the buffer to the handler, can use function object boost::bind. boost::bind(on_ read,buff,_1,_2) _1 and _2 correspond to the first and second arguments of an async_receive handler error_code and size_t, respectivelly. 7

8 Buffer Lifetime with Smart Pointers Using smart pointers, objectlifetimemanagement can be easier. class shared_buffer { boost::shared_array<char> buff; //like a shared pointer but for arrays int size; shared_buffer(size_t size) : buff(new char[size]), size(size) { //constructor auto asio_buff() const { return buffer(buff.get(), size); void on_read(shared_buffer sbuf, const boost::system::error_code & err, std::size_t read_bytes) { //the shared pointer assures sbuf still lives at this point // shared_buffer buff(512); sock.async_receive(buff.asio_buff(), boost::bind(on_ read, buff, _1, _2) ); 8

9 Buffer Lifetime Management with Shared this One can encapsulate data buffers and handlers on a helper class. Buffer lifetime can be managed by keeping the helper object alive by passinga shared pointer to the object itself(this) to the handler function. using namespace boost::asio; struct connection : boost::enable_shared_from_this<connection> { ip::tcp::socket sock_; char read_buffer_[1024]; connection(io_service service) : sock_(service) { void start(ip::tcp::endpoint ep) { sock_.async_connect(ep, boost::bind(&connection::on_connect, shared_from_this(), _1)); void on_connect(const boost::system::error_code & err) { // decide what to do with the connection, e.g. read sock_.async_read_some(buffer(read_buffer_), boost::bind(&connection::on_read, shared_from_this(), _1, _2)); void on_read(const boost::system::error_code & err, size_t bytes) { //can use read buffer safely ; // io_service service; ip::tcp::endpoint ep( ip::address::from_string(" "), 8001); connection::boost::shared_ptr<connection>( new connection {service )->start(ep); 9

10 Comments on Previous Slide Class enable_shared_from_this<t> defines two member functions called shared_from_this that return a shared_ptr<t> and shared_ptr<t const>, dependingon constness, to this. It also defines two member functions called weak_from_this that return a corresponding weak_ptr. Binding a shared pointerto the asynchronous operation handlers keeps the reference count positive, so the object cannot be destroyedbeforecompletion. 10

11 Asynchronous TCP Server #include <boost/bind.hpp> #include <boost/shared_ptr.hpp> #include <boost/enable_shared_from_this.hpp> #include <boost/asio.hpp> using namespace boost::asio; using ip::tcp; class tcp_connection : public boost::enable_shared_from_this<tcp_connection> { private: tcp::socket sock_; std::string msg_; tcp_connection(io_service& io) : sock_(io) { void handle_write() {/*nothing important*/ public: ; typedef boost::shared_ptr<tcp_connection> pointer; static pointer create(io_service& io) { return pointer(new tcp_connection(io)); tcp::socket& socket() {return socket_; void start() { async_write(sock_,buffer( Hello World ), boost::bind(&tcp_connection::handle_write, shared_from_this())); class tcp_server { private: tcp::acceptor acceptor_; public: tcp_server(io_service& io) : acceptor_(io, tcp::endpoint(tcp::v4(), 10000)) { private: start_accept(); void start_accept() { tcp_connection::pointer new_con = tcp_connection::create(acceptor_.get_io_service()); acceptor_.async_accept(new_con->socket(), boost::bind(&tcp_server::handle_accept, this, new_con)); ; void handle_accept(tcp_connection::pointer new_con) { new_con->start(); start_accept(); int main() { io_service io; tcp_server server(io); io.run(); 11

12 Debugging Asynchronous Operations Boost.Asio allows for handler tracking, when the macro BOOST_ASIO_ENABLE_HANDLER_TRACKING is defined. Outputs messages along asynchronous <timestamp> <action> <description>. Try on async_tcp_echo_server.cpp: #define BOOST_ASIO_ENABLE_HANDLER_TRACKING #include<boost/asio.hpp> Note: The #define must be before the #include 12

13 Debug Information //Start *1 //server creates hnd 1 (async_accept) //Client >1 ec=system:0 //enter hnd *2 socket@0x23c52f0.async_receive //hnd 1 creates hndr *3 socket@0x7ffca28b3298.async_accept //hnd 1 creates hnd <85112 //exit hnd 1 //Client send >2 ec=system:0,bytes_transferred=5 //enter hnd *4 socket@0x23c52f0.async_send //hnd 2 creates hnd < //exit hnd 2 //Server write >4 ec=system:0,bytes_transferred=5 //enter hnd *5 socket@0x23c52f0.async_receive //hnd 4 creates hnd < //exit hnd 4 //Server close >5 ec=asio.misc:2,bytes_transferred=0 //enter hnd socket@0x23c52f0.close //hnd 5 action socket < //exit hnd 5 13

14 Asynchronous Reading STDIN // MODIFY class server IN ASYNC_TCP_ECHO_SERVER using boost::asio::ip::tcp; using boost::system::error_code class server{ boost::asio::io_service& io_service_; tcp::acceptor acceptor_; boost::asio::posix::stream_descriptor input_; boost::asio::streambuf input_buffer_; public: server(boost::asio::io_service& io_service, short port) : io_service_(io_service), private: input_(io_service, ::dup(stdin_fileno)), input_buffer_(1024), acceptor_(io_service, tcp::endpoint(tcp::v4(), port)) { start_accept(); start_read_input(); void start_accept() { session* new_session = new session(io_service_); acceptor_.async_accept(new_session->socket(), boost::bind(&server::handle_accept, this, new_session, _1)); void start_read_input() { // Read a line of input entered by the user. boost::asio::async_read_until(input_, input_buffer_, '\n', boost::bind(&server::handle_read_input, this, _1, _2)); void handle_read_input( const error_code& error, std::size_t length){ std::cout << &input_buffer_ << std::endl; start_read_input(); void handle_accept(session* new_session, const error_code& error) { if (!error) { new_session->start(); else { delete new_session; start_accept(); ; int main(int argc, char* argv[]) { boost::asio::io_service io_service; server s(io_service, atoi(argv[1])); io_service.run(); 14