Tukukkk

I have a simple client-server application. Server is in Java, client in Python3. The server waits for a single client, then communicates with it for eternity in the following way. Server reads a line from the client, and the sends the message "yyyy" back. Thus, from the client side, the conversation could look something like this:

xxxx

> yyyy

xxxx

> yyyy

xxxx

> yyyy

...

The problem I have is with the speed of the communication. I measure the time it takes the server to read the client's request, and it is about 40ms. What is most surprising though, is that if the client appends an additional newline 'n' to each of its messages, the duration drops to ~0ms. What could be the cause of this, and how can I fix it so that I do not have to include an artificial newline to each client's request?

For completeness, I also provide the server side and client side code.

Server side:

import java.io.*;

import java.net.*;

import java.time.*;

import java.util.*;



class Server {

  public static void main (String args) {

    Clock clock = Clock.systemDefaultZone();

    try {

      ServerSocket server = new ServerSocket();

      server.bind(new InetSocketAddress("127.0.0.1", 4248));

      Socket client = server.accept();



      Scanner sc = new Scanner(client.getInputStream());

      PrintStream ps = new PrintStream(client.getOutputStream());



      while (true) {

        Instant start = clock.instant();

        String msg = sc.nextLine();

        Instant end = clock.instant();

        System.err.format("Took me %d ms to receive the messagen", Duration.between(start, end).getNano() / 1000000);

        ps.println("yyyy");

      }

    }

    catch (IOException exc) {}

  }

}

Client side:

import socket, sys



sock = socket.create_connection(("127.0.0.1", 4248))

fin = sock.makefile('r')

fout = sock.makefile('w')



while True:

  print("xxxx", file = fout, flush = True)

  msg = fin.readline().rstrip('n');

  print(msg, file = sys.stderr)

We obtain the "fast" client by replacing "xxxx" with "xxxxn". Note that Python3 automatically prints a newline after each message, so the the former really is "xxxxn" and the latter is "xxxxnn".

I measure the time it takes the server to read the client's request

Not only that, but you also measure (at least partially) the time until the client sends its request.

Just a guess

The Python client is the bottle neck and cannot keep up with the Java server. The server's nextLine() always waits for the client to print something.

When you change print("xxxx") to print("xxxxn") two lines are printed at once, which doubles the line output rate of the client. Now it's the other way around: The client sends messages faster than the server can process them and the client's readline() has to wait for the server.

Note that in the latter case, the messages alternate between "xxxx" and "". That's probably not what you want. However, you could use print("xxxxnxxxx").

You could test this theory by writing a Java client that uses println("xxxx"). Assuming the Java client is faster than the python client, I would expect the measured time to be less than 40ms but maybe a bit more than 0ms.