What is the fastest way to send data between client and server?

Question

I want to implement a communication between 2 servers. On the client side: one thread prepares the data and enqueues it. The second thread dequeues data, serializes it and sends to the server. On the server side: receives the data (bytes) and enqueues it. The further process of the enqueued data is irrelevant.

For test purposes only:

1. I run the client and the server on the same machine.
2. I imitate the queue by initiating records with a string of 70 bytes length (the object I want to send is about 70 bytes). See the Client->StartClient code below.
3. I send the data iteratively. The data will be queued very fast, so I want to send it as soon as it gets to the queue. I imitate it by sending it iteratively.

I used WCF for both client and server to send the data, but it took over 5min to send 70MB(1 million records of 70bytes each). Then I decided to use Socket. I used asynchronous approach and it still took a few minutes to send 70MB. In my understanding, having client and server on the same machine, it should NOT take a few minutes to send 70MB. It should take a few seconds max, right? How I can speed it up?

P.S. I know that you can say "accumulate and then send". But, I want to be able to send data as soon as it gets to the queue.

Client:

public class StateObject
{
    // Client socket.
    public Socket workSocket = null;
    // Size of receive buffer.
    public const int BufferSize = 256;
    // Receive buffer.
    public byte[] buffer = new byte[BufferSize];
    // Received data string.
    public StringBuilder sb = new StringBuilder();
}

public class AsynchronousClient
{
    // The port number for the remote device.
    private const int port = 11000;

    // ManualResetEvent instances signal completion.
    private static ManualResetEvent connectDone =
        new ManualResetEvent(false);
    private static ManualResetEvent sendDone =
        new ManualResetEvent(false);
    private static ManualResetEvent receiveDone =
        new ManualResetEvent(false);

    // The response from the remote device.
    private static String response = String.Empty;

    private static void StartClient()
    {
        // Connect to a remote device.
        try
        {                
            IPHostEntry ipHostInfo = Dns.Resolve("MY_HOST");
            IPAddress ipAddress = ipHostInfo.AddressList[0];
            IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);

            // Create a TCP/IP socket.
            Socket client = new Socket(AddressFamily.InterNetwork,
                SocketType.Stream, ProtocolType.Tcp);

            // Connect to the remote endpoint.
            client.BeginConnect(remoteEP,
                new AsyncCallback(ConnectCallback), client);
            connectDone.WaitOne();

//============================================================
            var records = new List<string>();                
            for (int i = 0; i < 1000000; i++)
            {
                records.Add(new string('a', 70));
            }

            var serializer = new BinaryFormatter();
            var stopWatch = new Stopwatch();
            stopWatch.Start();                
            foreach (var rec in records)
            {
                using (var ms = new MemoryStream())
                {
                    serializer.Serialize(ms, rec);
                    var serData = ms.ToArray();

                    // Send test data to the remote device.
                    Send(client, serData);                                                  
                }
            }
            stopWatch.Stop();    
//================================================================                                      
            // Release the socket.
            client.Shutdown(SocketShutdown.Both);
            client.Close();

        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

    private static void ConnectCallback(IAsyncResult ar)
    {
        try
        {
            // Retrieve the socket from the state object.
            Socket client = (Socket)ar.AsyncState;

            // Complete the connection.
            client.EndConnect(ar);

            Console.WriteLine("Socket connected to {0}",
                client.RemoteEndPoint.ToString());

            // Signal that the connection has been made.
            connectDone.Set();
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

    private static void Send(Socket client, byte[] data)
    {
        // Convert the string data to byte data using ASCII encoding.
        byte[] byteData = data;// Encoding.ASCII.GetBytes(data);

        // Begin sending the data to the remote device.
        client.BeginSend(byteData, 0, byteData.Length, 0,
            new AsyncCallback(SendCallback), client);
    }

    private static void SendCallback(IAsyncResult ar)
    {
        try
        {
            // Retrieve the socket from the state object.
            Socket client = (Socket)ar.AsyncState;

            // Complete sending the data to the remote device.
            int bytesSent = client.EndSend(ar);
            Console.WriteLine("Sent {0} bytes to server.", bytesSent);                   
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

    public static int Main(String[] args)
    {
        StartClient();
        return 0;
    }
}

Server:

public class StateObject
{
    // Client  socket.
    public Socket workSocket = null;
    // Size of receive buffer.
    public const int BufferSize = 1024;
    // Receive buffer.
    public byte[] buffer = new byte[BufferSize];
    // Received data string.
    public StringBuilder sb = new StringBuilder();
}

public class AsynchronousSocketListener
{
    // Thread signal.
    public static ManualResetEvent allDone = new ManualResetEvent(false);

    public AsynchronousSocketListener()
    {
    }

    public static void StartListening()
    {
        // Data buffer for incoming data.
        byte[] bytes = new Byte[1024];

        IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
        IPAddress ipAddress = ipHostInfo.AddressList[0];
        IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);

        // Create a TCP/IP socket.
        Socket listener = new Socket(AddressFamily.InterNetwork,
            SocketType.Stream, ProtocolType.Tcp);

        // Bind the socket to the local endpoint and listen for incoming connections.
        try
        {
            listener.Bind(localEndPoint);
            listener.Listen(100);

            while (true)
            {
                // Set the event to nonsignaled state.
                allDone.Reset();

                // Start an asynchronous socket to listen for connections.
                Console.WriteLine("Waiting for a connection...");
                listener.BeginAccept(
                    new AsyncCallback(AcceptCallback),
                    listener);

                // Wait until a connection is made before continuing.
                allDone.WaitOne();
            }

        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }

        Console.WriteLine("\nPress ENTER to continue...");
        Console.Read();

    }

    public static void AcceptCallback(IAsyncResult ar)
    {
        // Signal the main thread to continue.
        allDone.Set();

        // Get the socket that handles the client request.
        Socket listener = (Socket)ar.AsyncState;
        Socket handler = listener.EndAccept(ar);

        // Create the state object.
        StateObject state = new StateObject();
        state.workSocket = handler;
        handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
            new AsyncCallback(ReadCallback), state);
    }

    public static void ReadCallback(IAsyncResult ar)
    {
        String content = String.Empty;

        // Retrieve the state object and the handler socket
        // from the asynchronous state object.
        StateObject state = (StateObject)ar.AsyncState;
        Socket handler = state.workSocket;

        // Read data from the client socket. 
        int bytesRead = handler.EndReceive(ar);
        Console.WriteLine("Read {0} bytes from socket", bytesRead);

        handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
               new AsyncCallback(ReadCallback), state);
    }                

    public static int Main(String[] args)
    {
        StartListening();
        return 0;
    }
}

sdf

Answer 1

You've effectively cancelled out the benefit of the async pattern by blocking further progress with

sendDone.WaitOne();

In other words: You've managed to implement blocking socket IO with asynchronous calls: You do use async sending of data, but you're also waiting for it to be done without doing something else, so in effect, you might as well use blocking calls.

Instead of using the sendDone event to control the flow, you should determine in the EndSend() callback if there's more to be send, and start a new BeginSend().

Whether the blocking by the sendDone event is responsible for the full time consumed by the operation is impossible to say, but it sure doesn't help.

Answer 2

A few questions:

• Have you tried without Begin/End functions? I don't understand the use of the lock in the client send loop. Also, There is a slight overhead in using Begin/End methods in comparison to Async methods (the creation of a IAsyncResult object every call instead of recycling it) but I doubt this is a real issue.
• Have you timed the serialization of the message on the client side? I'm sure serializing once is fast, but perhaps looping 70MB of serialization is pressuring the GC. Try serializing once and sending the same block (which is essentially what you are doing).

Strategy:

• You need to find the bottle neck, why not use the VS profiler? it does a decent job.
• If you suspect the problem is the socket speed, try using a named pipe or shared memory.
• If you suspect the problem is with locking, try without locking.
• If you suspect the problem is with async methods, try synch methods.

Good luck!

Answer 3

WCF by default will use what is called "Buffered mode". This means that every byte needs to be sent before you start processing. This has two major implications.

1. It takes at least the time for the last byte to transfer + the time to process the data for the request to complete.
2. .net needs to dynamically allocate 70MB of buffer, but it does not know the size of the buffer at the start. As a result it actually allocates about 150MB of memory and copies the data back and forth lots of times.

The simplest way to fix this.

In your binding set your binding to use Stream mode. Then in your WCF contract replace all your method parameters with a single Stream parameter.