TCP-IP, C# Client and Java Server, very high latency

Question

In some tutoral-based codes, I connected a C# web application to a Java socket server through my web application's WebMethod in a webservice. Unfortunately this is happening pretty slowly. For example, when the Java server echoes some data to the C# client I get the following results:

• Size of data sent= 32MB, total time= 980 ms (no problem)
• Size of data sent= 4MB, total time= 530 ms (becomes somewhat slower)
• Size of data sent= 1MB, total time= 520 ms (absolutely bottlenecked)
• Size of data sent= 1kB, total time= 516 ms (this must be some constant latency of something)

I've read that people can make real-time communications (~60/s) and sometimes even millions of streams/s with some server apps. What could be the problem with my implementation? It is sending multiple messages over a single open connection, so the object creation overhead should only show up for the first message? Why am I getting ~500 ms overhead on my messaging?

The C# webmethod is initiated when the web-app starts and connects to the same Java server for every call to this webmethod.

public static IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
public static IPAddress ipAddress = ipHostInfo.AddressList[0];
public static IPEndPoint remoteEP = new IPEndPoint(ipAddress, 9999);

// Create a TCP/IP  socket.
public static Socket sender = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
public static int z = 0; 

[WebMethod]
public BenchmarkData_ StartClient()
{
    lock(lck)
    {
        z++;
        if (z == 1)
        {
            sender.Connect(remoteEP);
        }
    }
    int bytesRec = 0;
    int boy = 0;
    byte[] bytes = new byte[1024 * 1024];
    int bytesSent = 0;
    SocketFlags sf = new SocketFlags();
    Stopwatch sw = new Stopwatch(); Stopwatch sw2 = new Stopwatch();

    #region r
    lock (lck)
    {
        sw.Start();
        // Data buffer for incoming data.

        // Connect to a remote device.
        try
        {
            // Establish the remote endpoint for the socket.
            // This example uses port 11000 on the local computer.

            // Create a TCP/IP  socket.
            sender.ReceiveBufferSize = 1024 * 1024;
            sender.ReceiveTimeout = 1;

            // Connect the socket to the remote endpoint. Catch any errors.
            try
            {
                Console.WriteLine("Socket connected to {0}", sender.RemoteEndPoint.ToString());
                // Encode the data string into a byte array.
                byte[] msg = Encoding.ASCII.GetBytes("This is a test<EOF>");

                // Send the data through the socket.
                bytesSent = sender.Send(msg);

                // Receive the response from the remote device.
                sw.Stop();

                sw2.Start();
                while ((bytesRec = sender.Receive(bytes)) > 0)
                {
                    boy += bytesRec;
                }

                Console.WriteLine("Echoed test = {0}", Encoding.ASCII.GetString(bytes, 0, bytesRec));

                // Release the socket.
                // sender.Shutdown(SocketShutdown.Both);
                // sender.Close();
                sw2.Stop();
            }
            catch (ArgumentNullException ane)
            {
                Console.WriteLine("ArgumentNullException : {0}", ane.ToString());
            }
            catch (SocketException se)
            {
                Console.WriteLine("SocketException : {0}", se.ToString());
            }
            catch (Exception e)
            {
                Console.WriteLine("Unexpected exception : {0}", e.ToString());
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }
    #endregion

    return new BenchmarkData_() { .... };
}

Here is the Java code (half-pseudo code)

serverSocket=new ServerSocket(port); // in listener thread
Socket socket=serverSocket.accept(); // in listener thread

// in a dedicated thread per connection made:
out=new  BufferedOutputStream( socket.getOutputStream());
in=new DataInputStream(socket.getInputStream());        

boolean reading=true;
ArrayList<Byte> incoming=new ArrayList<Byte>();

while (in.available() == 0)
{
    Thread.sleep(3);    
}

while (in.available() > 0)
{
    int bayt=-2;
    try {
        bayt=in.read();
    } catch (IOException e) { e.printStackTrace(); }

    if (bayt == -1)
    {
        reading = false;
    }
    else
    {
        incoming.add((byte) bayt);                      
    }
}

byte [] incomingBuf=new byte[incoming.size()];
for(int i = 0; i < incomingBuf.length; i++)
{
    incomingBuf[i] = incoming.get(i);
}

msg = new String(incomingBuf, StandardCharsets.UTF_8);
if (msg.length() < 8192)
    System.out.println("Socket Thread:  "+msg);
else
    System.out.println("Socket Thread: long msg.");

OutputStreamWriter outW = new OutputStreamWriter(out);
System.out.println(socket.getReceiveBufferSize());
outW.write(testStr.toString()); // 32MB, 4MB, ... 1kB versions
outW.flush();

Answer 1

Problem solved in replacement of

while ((bytesRec = sender.Receive(bytes))>0)
{
   boy += bytesRec;
}

with

 while (sender.Available <= 0) ;

 while (sender.Available>0)
 {
      bytesRec = sender.Receive(bytes);
      boy += bytesRec;
 }

now its in microseconds for 1kB reads instead of 500ms. Because its checking a single integer instead of trying to read on whole buffer? Maybe. But it now doesnt read all the message sent from server. It needs some type of header to know how much to read on. Reads about several kilobytes even when server sends megabytes.

When server sends 3MB and client reads exactly same amount, it takes 30ms. Both in same machine. Trying to read more than server has sent, (even a single byte), raises an exception so TCP really sends exact same amount needed by client.