Delayed ACK at receiver vs. RTO at sender - c

Question

if H1 opens TCP connection to H2, then H1 sends a small packet ( < MSS ) to H2 (H2 is not to respond with data), how long will it take H2 to send a delayed ACK?
How TCP ensures that RTO timer at H1 wouldn't expire before receiving the delayed ACK?
Is it correct understanding that Linux has minimal RTO of 200ms by default, so if network is fast (RTO stays at minimal 200ms) and the data packet is lost on the way from H1 to H2, then H1 will retry in 200ms? If network is slow, then H1 may wait well longer than 200ms?

Answer 1

About delayed ACK timing, RFC 1122 says:
A TCP SHOULD implement a delayed ACK, but an ACK should not
be excessively delayed; in particular, the delay MUST be
less than 0.5 seconds, and in a stream of full-sized
segments there SHOULD be an ACK for at least every second
segment.
So it depend on implementation and of course if could reduce application performance.
In linux kernel they do not send delayed ACK by timer or fixed interval as you can see in following code they behave differently by conditions.
As you can see in net/ipv4/tcp_input.c, they says in comment:
There is something which you must keep in mind when you analyze the
behavior of the tp->ato delayed ack timeout interval. When a
connection starts up, we want to ack as quickly as possible. The
problem is that "good" TCP's do slow start at the beginning of data
transmission. The means that until we send the first few ACK's the
sender will sit on his end and only queue most of his data, because
he can only send snd_cwnd unacked packets at any given time. For
each ACK we send, he increments snd_cwnd and transmits more of his
queue. -DaveM
static void tcp_event_data_recv(struct sock *sk, struct sk_buff *skb)
{
struct tcp_sock *tp = tcp_sk(sk);
struct inet_connection_sock *icsk = inet_csk(sk);
u32 now;
inet_csk_schedule_ack(sk);
tcp_measure_rcv_mss(sk, skb);
tcp_rcv_rtt_measure(tp);
now = tcp_time_stamp;
if (!icsk->icsk_ack.ato) {
/* The _first_ data packet received, initialize
* delayed ACK engine.
*/
tcp_incr_quickack(sk);
icsk->icsk_ack.ato = TCP_ATO_MIN;
} else {
int m = now - icsk->icsk_ack.lrcvtime;
if (m <= TCP_ATO_MIN / 2) {
/* The fastest case is the first. */
icsk->icsk_ack.ato = (icsk->icsk_ack.ato >> 1) + TCP_ATO_MIN / 2;
} else if (m < icsk->icsk_ack.ato) {
icsk->icsk_ack.ato = (icsk->icsk_ack.ato >> 1) + m;
if (icsk->icsk_ack.ato > icsk->icsk_rto)
icsk->icsk_ack.ato = icsk->icsk_rto;
} else if (m > icsk->icsk_rto) {
/* Too long gap. Apparently sender failed to
* restart window, so that we send ACKs quickly.
*/
tcp_incr_quickack(sk);
sk_mem_reclaim(sk);
}
}
icsk->icsk_ack.lrcvtime = now;
tcp_ecn_check_ce(tp, skb);
if (skb->len >= 128)
tcp_grow_window(sk, skb);
}