Need help finding Fast Way to send a message to multiple sockets in a list object?

Im making a chat application, i already finished it but sometimes the messages are REALLY delayed for some clients. I have two methods, one called checkForMessages that checks the message on the sockets, and sendMessages which sendsthe message to all sockets. I have a list object of sockets that keeps trakc of the connections.

Here is my code for both methods
(this is the server code btw)

Code:

---

public void checkForMessages(List<Socket> s)
        {
            Byte[] byteBuffer = new Byte[1024];
            bool result;
            for (int i = 0; i < s.Count; ++i)
            {
                result = s[i].Poll(1000, SelectMode.SelectRead);
                if (result)
                {
                    Array.Clear(byteBuffer, 0, byteBuffer.Length);
                    s[i].Receive(byteBuffer);
                    sendMessages(s,byteBuffer);

                }
            }
        }



public void sendMessages(List<Socket> s,Byte[] bufferMessage)
        {
            for (int i = 0; i < s.Count; ++i)
            {
                    Socket sendMessage = s[i];
                    sendMessage.Send(bufferMessage);
            }



        }

---

Is there any other way i can send/recieve messages without it being so delayed sometimes?!

Your sending could be optimized to do it in parallel:

Code:

---

    public void sendMessages(List<Socket> s, Byte[] bufferMessage)
    {
      s.AsParallel().ForAll( socket => socket.Send(bufferMessage) );
    }

---

However, this will probably not be your delay. Check your receiving function. It will poll each socket for a second. Add 10 chatters and your program takes 10 seconds to recognize that one has sent something even before replicating it to it's clients.

Just guessing here, but the delay could be from blocking on receive. My guess is based on you using Send rather than BeginSend.

Quote:

---

Originally Posted by nvoigt

Your sending could be optimized to do it in parallel:

Code:

---

    public void sendMessages(List<Socket> s, Byte[] bufferMessage)
    {
      s.AsParallel().ForAll( socket => socket.Send(bufferMessage) );
    }

---

However, this will probably not be your delay. Check your receiving function. It will poll each socket for a second. Add 10 chatters and your program takes 10 seconds to recognize that one has sent something even before replicating it to it's clients.

---

Yeah its definitely my receive code, What would be a solution for this?

Quote:

---

Originally Posted by theoobe

Just guessing here, but the delay could be from blocking on receive. My guess is based on you using Send rather than BeginSend.

---

im using a non blocking method by polling the socket so that cant be it

Well, you told your "Poll" to wait for 1000. If that's too long, you could try 100 or 10 or 1 I guess. If you feel adventurous, you could try to receive in parallel, too.

Quote:

---

Originally Posted by nvoigt

Well, you told your "Poll" to wait for 1000. If that's too long, you could try 100 or 10 or 1 I guess. If you feel adventurous, you could try to receive in parallel, too.

---

okay i reduced the time but i still get a delay, that's odd, hmmm,the delay is random, sometimes it is delayed other times it isn't. Could it be because in my receive code i'm receiving a message then sending it to all clients, then receiving another message then sending it, could that slow it down? Could i just add all the received messages in a queue and then call send after all the messages are received? and send the contents of the queue out to the clients?

How many clients do you have, how long is your message and how long is the delay? A delay of a few seconds would be normal for simple code if you have a lot of clients (>1000) or a big message (some megabytes) or very short delays in debug mode (< 1s). If you are sending "hello world" between 10 clients, no delay should be visible.

Quote:

---

Originally Posted by nvoigt

How many clients do you have, how long is your message and how long is the delay? A delay of a few seconds would be normal for simple code if you have a lot of clients (>1000) or a big message (some megabytes) or very short delays in debug mode (< 1s). If you are sending "hello world" between 10 clients, no delay should be visible.

---

Well even with one client its delayed by a few seconds, sometimes its like a 10 second delay and thats just for one client connected, the delay is so random, its definitely in my recieve code, should i do what i said in my post about the queue? would that speed it up?

If it's actually in the seconds-range, maybe writing logs or debugging will help. Find out what happens in the time of the delay. How do you know when to call your receive function by the way? Is that some sort of timer or just an endless loop?

Quote:

---

Originally Posted by nvoigt

If it's actually in the seconds-range, maybe writing logs or debugging will help. Find out what happens in the time of the delay. How do you know when to call your receive function by the way? Is that some sort of timer or just an endless loop?

---

its in an endless loop, here is the loop, this loop resides in the main function, the previous lines before it just instantiate the class and its attributes, here is the code:
Client Queue is a list object that holds the connections

Code:

---

while (true)
                {
                    server.checkForDisconnections(server.ClientQueue);
                    server.checkForMessages(server.ClientQueue);
                    server.PollResult = server.IncomingConnection.Poll(100000, SelectMode.SelectRead);
                    if (server.PollResult)
                    {
                        server.AcceptedConnection = server.IncomingConnection.Accept();
                        server.ClientQueue.Add(server.AcceptedConnection);
                        Console.WriteLine("A client has connected");
                    }

                }

---

What do you think that 100000 in your Poll function call does?

Quote:

---

Originally Posted by nvoigt

What do you think that 100000 in your Poll function call does?

---

It waits for a socket to be accepted without the .accepted() call blocking it, i lowered the time for it to literally 1 and i was getting the delay still, i use the poll as a non blocking way so accept doesn't block the entire program

Quote:

---

Originally Posted by nvoigt

What do you think that 100000 in your Poll function call does?

---

Do you want me to zip up the client and server programs in two seperate zip files and you can run them? and see what im talking about in terms of the "delay"

I'd rather help you find it, so can can solve your problems on your own in the future :)

Have you tried to track down the delay? Which function takes that long? Have you printed some logs or measured the time of the functions?

Quote:

---

Originally Posted by nvoigt

I'd rather help you find it, so can can solve your problems on your own in the future :)

Have you tried to track down the delay? Which function takes that long? Have you printed some logs or measured the time of the functions?

---

No im not sure how to do that hahah :P! I debugged it but i didnt see any difference! I definitely think its the logic in the recieve code thats "inefficient" what do you think about that? Do you think theres a more efficient way of recieving messages and sending them? Because what im doing is recieving one then calling send and sending that message out to all users then recieving another one then calling send and sending it out to all users and repeating that process till all the messages are sent, both methods are using a loop to send to all users. DO you think i should recieve all messages then send them all out at once? or is that less efficient?

I think you should start to pinpoint where your delay is coming from. If you say you have a visible delay, then find out where it is. Print to console and observe where it's lagging. I'm really at a loss how to help you if you didn't even try the simplest debugging technique for three straight days.

Quote:

---

Originally Posted by shivam1992

It waits for a socket to be accepted without the .accepted() call blocking it, i lowered the time for it to literally 1 and i was getting the delay still, i use the poll as a non blocking way so accept doesn't block the entire program

---

If you specify a nonzero value for the first parameter of poll, it isn't nonblocking anymore - it blocks for a length of time up to the time you specified in Poll().

Lastly, there's not much reason to loop over a socket list and calling Poll() - use Socket.Select() instead, which is much more efficient at polling a set of sockets.

Quote:

---

Originally Posted by shivam1992

DO you think i should recieve all messages then send them all out at once? or is that less efficient?

---

Much less efficient unless you expect a huge, huge volume of traffic. Think about it like this - if the main loop is working properly, the time from a message coming in until the message is dispatched to all other clients should be on the order of milliseconds. How likely is it for two clients to both send a message within milliseconds of each other versus how likely is it that they won't?

I think your problem is likely to be the blocking code you have. Of the snippets you've posted, you've demonstrated a 100 second long block in your main loop, plus a n-second long block in receiving (where n is the number of connections). There could well be blocks in checkForDisconnections() as well.

If you're going to do this in the current design (check for disconnections, messages, and accept connections in a single loop), every poll() everywhere in the code should have a timeout of 0 so it's nonblocking. Any block anywhere in the code has the potential to stop your entire main loop until that block times out.

There are some other designs you could consider too:

1. To split the three main functions into separate threads, and block indefinitely on each thread until it has something to do. You'd need to handle thread synchronization on your list of sockets, so there's some overhead in terms of locking, but from a multitasking operating system point of view, blocking until an event is better than polling.

2. To use event-driven programming via use of the BeginAccept(), BeginReceive(), etc. methods, and use this to notify you when you need to do something. It still needs to be done in a thread-safe manner, but the framework would handle most of the details, except for thread safety on shared data such as the socket list.

I would use the asynchronous versions of the socket methods and not the blocking versions. You could try the AsParallel but I doubt it would yield anything different than the async versions. Both the async and AsParallel approach are better than the blocking approach. Note that AsParallel is not going to magically fix all threading issues.

C# makes this quite simple. I think my vote would be what Cat said and use the event driven non-blocking async methods and the appropriate lock mechanism to ensure it is all thread safe. It has been some time since I have done any of this in C# but if I remember correctly it did not take but a few hours to get it all working.