How to use non-blocking TCP?

[P@u1]

Hi,

I'm trying to use an sf::SocketTCP in non-blocking mode.
I want to use it like this:

Code: [Select]


if(/*socket is ready*/)
{
   socket.Send(...);
}
//if not ready continue the next main loop and send the date next time if the socket has become ready


How can I do this?
I need a method like
socket.IsReady(), but there is none.
Send() returns a status, but I want to check the status without actually sending anything.

Please help :-)

[Laurent]

Sockets are always ready to send. The NotReady status is used only if you call Receive and there's no data available.

[P@u1]

how can it be that they are always ready to send and they are still not blocking?

I think I can put in data much faster than it can be sent, so it would be nice to have a way to find out how fast data must be put in so that the sending process still catches up...
Otherwise I will have lots of data and it will be sent with a big delay and some queue (maybe deep in the operating system) will fill up more and more.

Any suggestions?

[xazax]

I wrote a class for that, you may check it out.

http://www.assembla.com/code/Xazax/subversion/nodes/Snippets/network.cpp?rev=42
http://www.assembla.com/code/Xazax/subversion/nodes/Snippets/network.h?rev=42

I'm not an experienced C++ coder, so it may not be perfect, but it worked for me.

Usage:

http://pastebin.com/6sPwcFxw

[Laurent]

how can it be that they are always ready to send and they are still not blocking?

Technically you're right, if you send data at a very high rate the socket won't be able to catch up and data will start to be queued.

The implementation should be able to handle this, so I guess that Send() will return NotReady as well if the socket send buffer is not empty (or full).  Honestly this has never really been tested. But sorry for my previous answer that was quite wrong

So you could do

Code: [Select]

if (socket.Send(...) == sf::Socket::NotReady)
{
    try again later
}
else
{
    ok, data sent
}

[P@u1]

Ok, thank you for your help, I will do some experiments now.

But it would be much nicer to be able to poll the status like

Code: [Select]


if(socket.GetStatus() == Socket::Done)
{
   //put in new date
}


The problem is that with you approach I always have to prepare a new packet without knowing if I will be able to sent it.

And does NotReady in this case mean that it will be sent later, or that it wont be sent at all?

And how does non-blocking io work for receiving?
I would try it like this:

Code: [Select]


sf::Packet toReceive;
socket >> receive;
if(!toReceive)
{
    //packet invalid, try again later...
}

Does it work like this?

[Laurent]

The problem is that with you approach I always have to prepare a new packet without knowing if I will be able to sent it.

If the socket is ready you'll send your packet, so it has to be ready anyway, right? Is it really a problem for you?

And does NotReady in this case mean that it will be sent later, or that it wont be sent at all?

It means that it's not sent at all.

And how does non-blocking io work for receiving?

Nothing is returned to you as long as NotReady is returned.

Code: [Select]

sf::Packet packet;
sf::Socket::Status status = socket.Receive(packet);
if (status == sf::Socket::NotReady)
    // nothing received, try again later
else if (status == sf::Socket::Done)
    // ok, data received
else if (status == sf::Socket::Error)
    // error
else if (status == sf::Socket::Disconnected)
    // disconnected

[Tank]

That's where message queues come in. Especially for larger streams (like file downloads/uploads) it's nearly guaranteed that write operations on your socket will block (or in case you set up your sockest to be non-blocking, returning without sending data).

The usual attempt is to fill a message queue (could be as easy as std::queue with some smart pointers to lower memory copy operations when delaying a packet) and work it down while the socket is ready to send.