rmem | MTuner SDK - Memory profiling library | Monitoring library

If the server is killing the job, your memory settings are probably too high - since it's the OS killing it, and not the JVM creating an out of memory exception. In effect you're telling the JVM to use more memory than the OS allows it to; reduce the memory made available to the JVM and let it run its GC instead.

If you give the JVM 24G, and the total allocated memory on your server is 24G, the JVM will eat everything and get killed when there is no more room available. On your laptop this setting is different and it doesn't get killed because it uses too much memory.

The JVM believes it has as access to at least as much memory as you tell it, and then the OS underneath sees that "oh, that jvm process is sure using a lot of memory .. and I'm all out of available memory .. guess I'll have to kill it". When this happens, the process just disappears and won't be able to log anything (except to the syslog or depending on your operating system, a different log, which will tell you that it what got killed).

R stands for reserved. So they can be interpreted as:

a)Is this buffer, TCP receive window?

No, it is just a buffer that you provide for the TCP stack to place bytes into when you call recv().

b)Is there any relation between this buffer and .net.ipv4.tcp_rmem , .net.ipv4.tcp_wmem?

No.

if yes, Should i set read buffer based on rmem or women?

You can pass any size buffer you want to recv(); it is unrelated to any of the above, except that there isn't any benefit to making the buffer you pass to recv() larger than the socket's current SO_RCVBUF size, since it's unlikely that recv() would ever return more bytes at once than can be present in the socket's internal buffer.

As for how to decide what size buffer to use -- consider that a larger buffer will (of course) take up more memory, and if you are allocating that buffer on the stack, a very large buffer might cause a stack overflow. On the other hand, a smaller buffer means that you can read fewer bytes with any given call to recv(), so you may have to call recv() more times to read in the same total number of bytes.

Note that number of bytes of data returned by recv() may be any number from 1 byte up to the total size of the buffer that you passed in to recv()'s third argument, and there is no way to predict how many bytes you'll get. In particular, with TCP the number of bytes you receive from any particular call to recv() will not have any correlation to the number of bytes previously passed to any particular call to send() on the sending side. So you just need to use a "reasonably sized" array (for whatever definition of "reasonably sized" you prefer) and recv() as many bytes into it as possible, and then handle that many bytes (based on recv()'s return value).