tcp_rmem – vector of 3 INTEGERs: min, default, max

ABOUT tcp_rmem

min: Minimal size of receive buffer used by TCP sockets.

It is  guaranteed to  each TCP socket,  even under  moderate memory
pressure.  Default: 1 page

default: initial size of receive  buffer used by TCP sockets.  This value  overrides net.core.rmem_
default  used by  other  protocols. Default: 87380  bytes. This value  results in window of  100535
with default setting  of tcp_adv_win_scale  and tcp_app_win:0 and  a bit less for default tcp_app_win.
See below about these variables.

max:  maximal  size of  receive  buffer  allowed for  automatically selected  receiver buffers  for  TCP
socket.  This  value does  not override  net.core.rmem_max.  Calling  setsockopt()  with SO_RCVBUF
disables automatic tuning of  that socket's receive buffer size, in which case this value is ignored.
Default: between 87380B and 4MB, depending on RAM size.

TYPICAL COMMANDLINE SESSION
[bash]
$cat /proc/sys/net/ipv4/tcp_rmem
4096 87380 2003296
$
[/bash]

TYPICAL NETWORK RELATED SOURCE CODE
[c]
/* the caller has to hold the sock lock */
static int rds_tcp_read_sock(struct rds_connection *conn, gfp_t gfp,
enum km_type km)
{
struct rds_tcp_connection *tc = conn->c_transport_data;
struct socket *sock = tc->t_sock;
read_descriptor_t desc;
struct rds_tcp_desc_arg arg;

/* It’s like glib in the kernel! */
arg.conn = conn;
arg.gfp = gfp;
arg.km = km;
desc.arg.data = &arg;
desc.error = 0;
desc.count = 1; /* give more than one skb per call */

tcp_read_sock(sock->sk, &desc, rds_tcp_data_recv);
rdsdebug("tcp_read_sock for tc %p gfp 0x%x returned %dn", tc, gfp,
desc.error);

return desc.error;
}
[/c]

RELATED KNOWLEDGE

TCP  performance depends  not upon  the transfer  rate  itself, but rather upon  the product  of the
transfer  rate and  the round-trip delay.  This "bandwidth*delay product"  measures the amount of data
that  would "fill the  pipe"; it  is the  buffer space  required at sender  and  receiver  to  obtain
maximum throughput  on  the  TCP connection over  the path, i.e., the amount  of unacknowledged data
that  TCP must  handle in  order to  keep the  pipeline  full.  TCP performance  problems  arise when
the  bandwidth*delay product  is large.  We refer to an Internet  path operating in this region as a
"long, fat  pipe", and a network  containing this path  as an "LFN" (pronounced "elephan(t)").
 

High-capacity  packet satellite  channels  (e.g., DARPA's  Wideband Net) are LFN's.   For example, a DS1
speed satellite  channel has a bandwidth*delay product of 10**6  bits or more; this corresponds to
100  outstanding  TCP segments  of  1200  bytes each.   Terrestrial fiber-optical paths will also fall
into the LFN class; for example, a cross-country  delay of  30 ms at  a DS3 bandwidth  (45Mbps) also
exceeds 10**6 bits.

LINK
https://tools.ietf.org/html/rfc1323

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s