HP-UX TCP/IP Performance White Paper, March 2008

following formula:

min((4 * MSS), max(2 * MSS, 4380))

where MSS is the maximum segment size for the underlying link.

With the new congestion window formula, it is possible for TCP to

send a large, initial block of data without waiting for

acknowledgements. This is useful in networks with large

bandwidth and low error rates and particularly useful for

short-lived connections that only need to send ~4Kbytes of data

or less.

To modify the initial congestion window, configure the ndd TCP

parameter tcp_cwnd_initial. TCP will calculate the initial

congestion window using the following formula:

min((tcp_cwnd_initial * MSS), max(2 * MSS, 4380)),

[1-4] Default 4: (TCP implements RFC 2414)

The congestion window is a window different from the "classic" TCP window. The Classic TCP Window is

advertised by the receiving TCP and is communicated in the TCP header. It implements flow control

between the sending and receiving TCPs.

The congestion window is a "window" tracked by the sending TCP and it is not communicated in the TCP

header. It is used by the sending TCP to implement a form of flow control and receiving TCPs. The sending

TCP keeps track of how many segments/bytes it can have outstanding on the network before triggering

packet loss.

At the beginning of a connection a sending TCP does not know how many segments/bytes it can have

outstanding, so in the "be conservative in what you send" Internet philosophy it starts with a congestion

window of two segments.

However, even the initial value of two can be rather limiting for connections which need only send a small

quantity of data (eg three or four segments' worth -- say a web server).

This parameter takes values of between one (1) and four (4) segments, with a default of four(4). At the

beginning of a connection, the sending TCP will send no more than (tcp_cwnd_initial* MSS) or 4380

bytes, whichever is less. After that, it will stop, and await the first ACKs from the remote before sending

additional data (if any).

tcp_deferred_ack_max:

Upper limit on the number of bytes of data (measured in MSS) that

can be received without sending an ACK.

[2-32] Default: 22 MSS

TCP follows an ACK strategy which is an extension of the "every other segment" approach described in

RFC 1122. TCP will defer sending ACKs until it has received ack_cnt >= ack_cur_max bytes. Initially

ack_cur_max is equal to 1 MSS. Each time TCP is successfully able to defer sending ACKs for

ack_cur_max bytes (that is, no timer expired for unacknowledged data), TCP increases ack_cur_max by

1 MSS, up to an absolute maximum of ack_abs_max. The tunable parameter tcp_deferred_ack_max

sets the upper bound for the delay before an ACK is sent.