using boost sockets, do I need only one io_service?

Question

having several connections in several different threads.. I'm basically doing a base class that uses boost/asio.hpp and the tcp stuff there.. now i was reading this: http://www.boost.org/doc/libs/1_44_0/doc/html/boost_asio/tutorial/tutdaytime1.html it says that "All programs that use asio need to have at least one io_service object." so should my base class has a static io_service (which means there will be only 1 for all the program and a all the different threads and connections will use the same io_service object) or make each connection its own io_service?

thanks in front!

update: OK so basically what I wish to do is a class for a basic client which will have a socket n it. For each socket I'm going to have a thread that always-receives and a different thread that sometimes sends packets. after looking in here: www.boost.org/doc/libs/1_44_0/doc/html/boost_asio/reference/ip__tcp/socket.html (cant make hyperlink since im new here.. so only 1 hyperling per post) I can see that socket class isn't entirely thread-safe..

so 2 questions: 1. Based on the design I just wrote, do I need 1 io_service for all the sockets (meaning make it a static class member) or I should have one for each? 2. How can I make it thread-safe to do? should I put it inside a "thread safe environment" meaning making a new socket class that has mutexes and stuff that doesn't let u send and receive at the same time or you have other suggestions? 3. Maybe I should go on a asynch design? (ofc each socket will have a different thread but the sending and receiving would be on the same thread?)

just to clarify: im doing a tcp client that connects to a lot of servers.

Solution 1

You need to decide first which style of socket communication you are going to use:

1. synchronous - means that all low-level operations are blocking, and typically you need a thread for the accept, and then threads (read thread or io_service) to handle each client.

2. asynchronous - means that all low-level operations are non-blocking, and here you only need a single thread (io_service), and you need to be able to handle callbacks when certain things happen (i.e. accepts, partial writes, result of reads etc.)

Advantage of approach 1 is that it's a lot simpler to code (??) than 2, however I find that 2 is most flexible, and in fact with 2, by default you have a single threaded application (internally the event callbacks are done in a separate thread to the main dispatching thread), downside of 2 of course is that your processing delay hits the next read/write operations... Of course you can make multi-threaded applications with approach 2, but not vice-versa (i.e. single threaded with 1) - hence the flexibility...

So, fundamentally, it all depends on the selection of style...

EDIT: updated for the new information, this is quite long, I can't be bothered to write the code, there is plenty in the boost docs, I'll simply describe what is happening for your benefit...

[main thread] - declare an instance of io_service - for each of the servers you are connecting to (I'm assuming that this information is available at start), create a class (say ServerConnection), and in this class, create a tcp::socket using the same io_service instance from above, and in the constructor itself, call async_connect, NOTE: this call is a scheduling a request for connect rather than the real connection operation (this doesn't happen till later) - once all the ServerConnection objects (and their respective async_connects queued up), call run() on the instance of io_service. Now the main thread is blocked dispatching events in the io_service queue.

[asio thread] io_service by default has a thread in which scheduled events are invoked, you don't control this thread, and to implement a "multi-threaded" program, you can increase the number of threads that the io_service uses, but for the moment stick with one, it will make your life simple...

asio will invoke methods in your ServerConnection class depending on which events are ready from the scheduled list. The first event you queued up (before calling run()) was async_connect, now asio will call you back when a connection is established to a server, typically, you will implement a handle_connect method which will get called (you pass the method in to the async_connect call). On handle_connect, all you have to do is schedule the next request - in this case, you want to read some data (potentially from this socket), so you call async_read_some and pass in a function to be notified when there is data. Once done, then the main asio dispatch thread will continue dispatching other events which are ready (this could be the other connect requests or even the async_read_some requests that you added).

Let's say you get called because there is some data on one of the server sockets, this is passed to you via your handler for async_read_some - you can then process this data, do as you need to, but and this is the most important bit - once done, schedule the next async_read_some, this way asio will deliver more data as it becomes available. VERY IMPORTANT NOTE: if you no longer schedule any requests (i.e. exit from the handler without queueing), then the io_service will run out of events to dispatch, and run() (which you called in the main thread) will end.

Now, as for writing, this is slightly trickier. If all your writes are done as part of the handling of data from a read call (i.e. in the asio thread), then you don't need to worry about locking (unless your io_service has multiple threads), else in your write method, append the data to a buffer, and schedule an async_write_some request (with a write_handler that will get called when the buffer is written, either partially or completely). When asio handles this request, it will invoke your handler once the data is written and you have the option of calling async_write_some again if there is more data left in the buffer or if none, you don't have to bother scheduling a write. At this point, I will mention one technique, consider double buffering - I'll leave it at that. If you have a completely different thread that is outside of the io_service and you want to write, you must call the io_service::post method and pass in a method to execute (in your ServerConnection class) along with the data, the io_service will then invoke this method when it can, and within that method, you can then buffer the data and optionally call async_write_some if a write is currently not in progress.

Now there is one VERY important thing that you must be careful about, you must NEVER schedule async_read_some or async_write_some if there is already one in progress, i.e. let's say you called async_read_some on a socket, until this event is invoked by asio, you must not schedule another async_read_some, else you'll have lots of crap in your buffers!

A good starting point is the asio chat server/client that you find in the boost docs, it shows how the async_xxx methods are used. And keep this in mind, all async_xxx calls return immediately (within some tens of microseconds), so there are no blocking operations, it all happens asynchronously. http://www.boost.org/doc/libs/1_39_0/doc/html/boost_asio/example/chat/chat_client.cpp, is the example I was referring to.

Now if you find that performance of this mechanism is too slow and you want to have threading, all you need to do is increase the number of threads that are available to the main io_service and implement the appropriate locking in your read/write methods in ServerConnection and you're done.

Solution 2

For asynchronous operations, you should use a single io_service object for the entire program. Whether its a static member of a class, or instantiated elsewhere is up to you. Multiple threads can invoke its run method, this is described in Inverse's answer.

Multiple threads may call io_service::run() to set up a pool of threads from which completion handlers may be invoked. This approach may also be used with io_service::post() to use a means to perform any computational tasks across a thread pool.

Note that all threads that have joined an io_service's pool are considered equivalent, and the io_service may distribute work across them in an arbitrary fashion.

if you have handlers that are not thread safe, read about strands.

A strand is defined as a strictly sequential invocation of event handlers (i.e. no concurrent invocation). Use of strands allows execution of code in a multithreaded program without the need for explicit locking (e.g. using mutexes).

Solution 3

The io_service is what invokes all the handler functions for you connections. So you should have one running for thread in order to distribute the work across threads. Here is a page explain the io_service and threads:

Threads and Boost.Asio

Comments

[grich]

wait so i need one for the "receiving thead" and one for the "sending thread"? or one for each socket?

[grich]

yea ok what i dont get is this: i want to make a thread for always receiving and my "main thread" would sometimes send packets.. so I'll have to use the same socket for both operations, but the problem is i see it is not thread-safe to do so in this why.. so what should i do?

[Nim]

Try not to think interms of threads, instead, update the above question with what it is you are intending to do, how do you want this server to work? May be easier to answer then...

[grich]

I'm not doing a sever, I'm doing a client that connects to a-lot of servers. Anyways i edited my question to clarify everything better, Tnx.

[grich]

Tnx a lot but I didn't understand some parts of what you wrote. First thing first, some of my writing would be as a respond to the received data, and some of it wont be as a respond and just random writing. i didn't understand the double buffer thing you offered.. I want to write, so I call io_service::post with a method from ServerConnection (lets call it sendMsg).. and sendMsg should call async_send (why did u use async_write_some btw?) and that will make it a thread-safe operation? and before calling async_send i should lock and after it i should unlock? what about the recive?

[grich]

@Nim hi m8 can u read my last comment and please respond :)? Tnx

[Nim]

@grich, day job is in the way! ;) From the external thread, you must call io_service::post(). Then the io_service will invoke the method when it's ready, at which point you can write the data to the buffer. Within the context of the io_service (let's say it's called you back on your read handler), you don't need to post(), you can simply append the data to a write buffer and call write.

[Nim]

btw, the method which is called via post must acquire a mutex so that it doesn't clash with a callback from io_service when a write is done (this is a problem if you have multiple threads in your io_service), if you have one, this is not a problem! What I meant by double buffering is that you should keep a pending buffer, to which you append new data (via the post() invoked method) or normal write request (in the context of the io_service), and swap this with an active buffer once the active buffer has been drained. In the handler that gets invoked after a partial write, you must check to see

[Nim]

..if there is any more data in the active buffer, if so, write that first and then once that's done, swap that with the pending buffer. NOTE: none of these operations are thread safe if you have multiple threads in your io_service.

[grich]

@Nim tnx for the help :) I do have multiple threads running io_service::run. What I understood from what you told me is that I should have one async_read max at all time and that i should have one async_send max at all time. I asked if I can have async_send and async_recive both at the same time and ppl said I can. For doing that, Sam Miller suggested using boost:asio:strand so I can make sure only 1 async_write is being called each time.. The others would have to wait, did I get it right? Is that what i meant when u said "e method which is called via post must acquire a mutex"?

[user]

I see a discrepancy between your answer and the doc you linked to. The doc says that run() may be called by multiple threads to set up a thread pool. As I understand it's about multiple call of one instance's method and not about multiple instances.

[MSalters]

I disagree with this answer. I've found out that multiple threads sharing an io_service can block each other. In my case, I had two threads, both adding a TCP read and a deadline timer, so the shared io_service object had 4 completion handlers to deal with. This caused one read to block on the other read, even though they did not share a socket. The problem was resolved by using per-thread io_service objects, each dealing with just one read and one timeout.