title: Fast IPC/Socket communication in Java/Python
body: <p>Two processes (Java and Python) need to communicate in my application. I noticed that the socket communication takes 93% of the run time. Why is communication so slow? Should I be looking for alternatives to socket communication or can this be made faster?</p>
  
  <p>Update: I discovered a simple fix. It seems like the Buffered output stream is not really buffered for some unknown reason. So, I now put all data into string buffers in both client/server processes. I write it to the socket in the flush method.</p>
  
  <p>I'm still interested in an example of the usage of shared memory to exchange data quickly between processes.</p>
  
  <p>Some additional information:</p>
  
  <ol>
  <li>Message size in the applicaiton is under 64kb most of the time.</li>
  <li>The server is in Java, the client is written in Python.</li>
  <li>Socket IPC is implemented below: it takes 50 cycles sending 200 bytes ! This has got to be too high. If I send 2 bytes in 5000 cycles, it takes a lot less time.</li>
  <li>Both processes run on one Linux machine.</li>
  <li>In the real application about 10 calls to client's iFid.write() are made each cycle.</li>
  <li>This is done on a Linux system.</li>
  </ol>
  
  <p>This is the server side:</p>
  
  <pre><code>public class FastIPC{
      public PrintWriter out;
      BufferedReader in;
      Socket socket = null;
      ServerSocket serverSocket = null;
  
  
      public FastIPC(int port) throws Exception{
          serverSocket = new ServerSocket(port);
          socket = serverSocket.accept();
          out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);
          in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
      }
  
      public void send(String msg){
          out.println(msg); // send price update to socket
      }
  
      public void flush(){
          out.flush();
      }
  
      public String recv() throws Exception{
          return in.readLine();
      }
  
      public static void main(String[] args){
          int port = 32000;
          try{
              FastIPC fip = new FastIPC(port);
              long start = new Date().getTime();
              System.out.println("Connected.");
              for (int i=0; i&lt;50; i++){
                  for(int j=0; j&lt;100; j++)
                      fip.send("+");
                  fip.send(".");
                  fip.flush();
                  String msg = fip.recv();
              }
              long stop = new Date().getTime();
              System.out.println((double)(stop - start)/1000.);
          }catch(Exception e){
              System.exit(1);
          }
      }
  }
  </code></pre>
  
  <p>And the client side is:</p>
  
  <pre><code>import sys
  import socket
  
  class IPC(object):
      def __init__(self):
          self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
          self.s.connect(("localhost", 32000))
          self.fid = self.s.makefile() # file wrapper to read lines
          self.listenLoop() # wait listening for updates from server
  
      def listenLoop(self):
          fid = self.fid
          print "connected"
          while True:
              while True:
                  line = fid.readline()
                  if line[0]=='.':
                      break
              fid.write('.\n')
              fid.flush()
  
  if __name__ == '__main__':
      st = IPC()
  </code></pre>