Lecture 16 TCP in detail Eric Anderson Fall 2013 wwwcscmueduprs15441F13 2 Good Ideas So Far Flow control Stop amp wait Sliding window Loss recovery Timeouts Acknowledgementdriven recovery ID: 653172
Download Presentation The PPT/PDF document "15-441 Computer Networking" is the property of its rightful owner. Permission is granted to download and print the materials on this web site for personal, non-commercial use only, and to display it on your personal computer provided you do not modify the materials and that you retain all copyright notices contained in the materials. By downloading content from our website, you accept the terms of this agreement.
Slide1
15-441 Computer Networking
Lecture 16 –TCP in detail
Eric Anderson
Fall 2013
www.cs.cmu.edu/~prs/15-441-F13Slide2
2
Good Ideas So Far…
Flow control
Stop & wait
Sliding window
Loss recovery
Timeouts
Acknowledgement-driven recovery
Selective repeat
Cumulative acknowledgement
Congestion control
AIMD
fairness and efficiency
How does TCP actually implement these?Slide3
3
Outline
TCP connection setup/data transfer
TCP Packet Loss and Retransmission
TCP congestion avoidance
TCP slow startSlide4
4
Sequence Number Space
Each byte in byte stream is numbered.
32 bit value
Wraps around
Initial values selected at start up time
TCP breaks up the byte stream into packets.
Packet size is limited to the Maximum Segment Size
Each packet has a sequence number.
Indicates where it fits in the byte stream
packet 8
packet 9
packet 10
13450
14950
16050
17550Slide5
5
Establishing Connection:
Three-Way handshake
Each side notifies other of starting sequence number it will use for sending
Why not simply chose 0?
Must avoid overlap with earlier incarnation
Security issues
Each side acknowledges other’s sequence number
SYN-ACK: Acknowledge sequence number + 1
Can combine second SYN with first ACK
SYN: SeqC
ACK: SeqC+1
SYN: SeqS
ACK: SeqS+1
Client
ServerSlide6
6
TCP Connection Setup Example
Client SYN
SeqC: Seq. #4019802004, window 65535, max. seg. 1260
Server SYN-ACK+SYN
Receive: #4019802005 (= SeqC+1)
SeqS: Seq. #3428951569, window 5840, max. seg. 1460
Client SYN-ACK
Receive: #3428951570 (= SeqS+1)
09:23:33.042318 IP 128.2.222.198.3123 > 192.216.219.96.80:
S 4019802004:4019802004(0) win 65535
<mss 1260,nop,nop,sackOK> (DF)
09:23:33.118329 IP 192.216.219.96.80 > 128.2.222.198.3123:
S 3428951569:3428951569(0) ack 4019802005 win 5840 <mss 1460,nop,nop,sackOK> (DF)09:23:33.118405 IP 128.2.222.198.3123 > 192.216.219.96.80: . ack 3428951570 win 65535 (DF)Slide7
7
TCP State Diagram: Connection Setup
CLOSED
SYN
SENT
SYN
RCVD
ESTAB
LISTEN
active OPEN
create TCB
Snd SYN
create TCB
passive OPEN
delete TCB
CLOSE
delete TCB
CLOSE
snd SYN
SEND
snd SYN ACK
rcv SYN
Send FIN
CLOSE
rcv ACK of SYN
Snd ACK
Rcv SYN, ACK
rcv SYN
snd ACK
Client
ServerSlide8
8
CLOSED
LISTENSYN_RCVDSYN_SENT
ESTABLISHED
CLOSE_WAIT
LAST_ACK
CLOSING
TIME_WAIT
FIN_WAIT_2
FIN_WAIT_1
Passive open
Close
Send/
SYN
SYN/SYN + ACK
SYN + ACK/ACKSYN/SYN + ACK
ACK
Close/FINFIN/ACKClose
/FINFIN/ACKACK + FIN/ACKTimeout after two
segment lifetimesFIN/ACKACKACKACK
Close
/FIN
Close
CLOSED
Active open
/SYN
TCP State Diagram: Connection Setup
s
cSlide9
9
Tearing Down Connection
Either side can initiate tear down
Send FIN signal
“I’m not going to send any more data”
Other side can continue sending data
Half open connection
Must continue to acknowledge
Acknowledging FIN
Acknowledge last sequence number + 1
A
B
FIN, SeqA
ACK, SeqA+1
ACK
Data
ACK, SeqB+1
FIN, SeqBSlide10
10
TCP Connection Teardown Example
Session
Echo client on 128.2.222.198, server on 128.2.210.194
Client FIN
SeqC: 1489294581
Server ACK + FIN
Ack: 1489294582 (= SeqC+1)
SeqS: 1909787689
Client ACK
Ack: 1909787690 (= SeqS+1)
09:54:17.585396 IP 128.2.222.198.4474 > 128.2.210.194.6616:
F 1489294581:1489294581(0) ack 1909787689 win 65434 (DF)
09:54:17.585732 IP 128.2.210.194.6616 > 128.2.222.198.4474: F 1909787689:1909787689(0) ack 1489294582 win 5840 (DF)09:54:17.585764 IP 128.2.222.198.4474 > 128.2.210.194.6616: . ack 1909787690 win 65434 (DF)Slide11
11
State Diagram: Connection Tear-down
CLOSING
CLOSE
WAIT
FIN
WAIT-1
ESTAB
TIME WAIT
snd FIN
CLOSE
send FIN
CLOSE
rcv ACK of FIN
LAST-ACK
CLOSED
FIN WAIT-2
snd ACK
rcv FIN
delete TCB
Timeout=2msl
send FIN
CLOSE
send ACK
rcv FIN
snd ACK
rcv FIN
rcv ACK of FIN
snd ACK
rcv FIN+ACK
ACK
Active Close
Passive CloseSlide12
12
CLOSED
LISTENSYN_RCVDSYN_SENT
ESTABLISHED
CLOSE_WAIT
LAST_ACK
CLOSING
TIME_WAIT
FIN_WAIT_2
FIN_WAIT_1
Passive open
Close
Send/
SYN
SYN/SYN + ACK
SYN + ACK/ACKSYN/SYN + ACK
ACK
Close/FINFIN/ACKClose
/FINFIN/ACKACK + FIN/ACKTimeout after two
segment lifetimesFIN/ACKACKACK//ACK
Close
/FIN
Close
CLOSED
Active open
/SYN
TCP State Diagram: Connection Teardown
A
B
“half-closed”
B→A still openSlide13
13
Outline
TCP
connection setup/data transfer
Packet Loss and Retransmission
Recognizing packet loss
Identifying missing packets
Retransmission behavior
TCP congestion avoidance
TCP slow startSlide14
14
Reliability Challenges
Congestion related losses
Variable packet delays
What should the timeout be?
Reordering of packets
How to tell the difference between a delayed packet and a lost one?Slide15
15
TCP = Go-Back-N Variant
Sliding window with cumulative acks
Receiver can only return a single “ack” sequence number to the sender.
Acknowledges all bytes with a lower sequence number
Starting point for retransmission
Duplicate acks sent when out-of-order packet received
But: sender only retransmits a single packet.
Reason???
Only one that it knows is lost
Network is congested
shouldn’t overload it
Error control is based on byte sequences, not packets.Retransmitted packet can be different from the original lost packet – Why?Slide16
16
Outline
TCP
connection setup/data transfer
Packet Loss and Retransmission
Recognizing packet loss
Identifying missing packets
Retransmission behavior
TCP congestion avoidance
TCP slow startSlide17
Retransmit Timeout
How long is too long?
Well, how long does it usually take?Early TCP: RTO = 2 x RTTLast 20 years: RTO = RTT + 4x deviationWhat’s the RTT? What’s the deviation?17Slide18
18
Round-trip Time Estimation
Wait at least one RTT before retransmitting
Importance of accurate RTT estimators:
Low RTT estimate
unneeded retransmissions
High RTT estimate
poor throughput
RTT estimator must adapt to change in RTT
But not too fast, or too slow!
Spurious timeouts
“Conservation of packets” principle – never more than a window worth of packets in flightSlide19
19
Original TCP Round-trip Estimator
Round trip times exponentially averaged:
New RTT =
a
(old RTT) + (1 -
a
) (new sample)
Recommended value for
a
: 0.8 - 0.9
0.875 for most TCP’s
Retransmit timer set to (b * RTT), where b = 2
Every time timer expires, RTO exponentially backed-offNot good at preventing spurious timeoutsWhy?Slide20
20
Jacobson’s Retransmission Timeout
Key observation:
At high loads, round trip variance is high
Solution:
Base RTO on RTT and standard deviation
RTO = RTT + 4 *
rttvar
new_rttvar
=
b
* dev
+ (1- b) old_rttvarDev = linear deviation Inappropriately named – actually smoothed linear deviationSlide21
21
RTT Sample Ambiguity
Karn’s RTT Estimator
If a segment has been retransmitted:
Don’t count RTT sample on ACKs for this segment
Keep backed off time-out for next packet
Reuse RTT estimate only after one successful transmission
A
B
ACK
Sample
RTT
Original transmission
retransmission
RTO
A
B
Original transmission
retransmission
Sample
RTT
ACK
RTO
XSlide22
22
Timestamp Extension
Used to improve timeout mechanism by more accurate measurement of RTT
When sending a packet, insert current time into option
4 bytes for time, 4 bytes for echo a received timestamp
Receiver echoes timestamp in ACK
Actually will echo whatever is in timestamp
Removes retransmission ambiguity
Can get RTT sample on any packetSlide23
23
Timer Granularity
Many TCP implementations set RTO in multiples of 200,500,1000ms
Why?
Avoid spurious timeouts – RTTs can vary quickly due to cross traffic
Make timers interrupts efficient
What happens for the first couple of packets?
Pick a very conservative value (seconds)Slide24
ACKs & NACKs
TCP has no NACK
24…ACK 12ACK 13ACK 14ACK 14ACK 14ACK 14 …Send 12Send 13Send 14Send 15Send 16Send 17Send 18Send 19…Slide25
25
Duplicate ACKs (Fast Retransmit)
What are duplicate
acks
(
dupacks
)?
Repeated
acks
for the same sequence
When can duplicate acks occur?
LossPacket re-ordering
Window update – advertisement of new flow control windowAssume re-ordering is infrequent and not of large magnitudeReceipt of 3 or more duplicate acks is indication of lossDon’t wait for timeout to retransmit packetWhen does this fail?Slide26
26
Duplicate ACKs (Fast Retransmit)
Time
Sequence No
Duplicate Acks
Retransmission
X
Packets
AcksSlide27
27
Outline
TCP
connection setup/data transfer
Packet Loss and Retransmission
Recognizing packet loss
Identifying missing packets
Retransmission behavior
TCP congestion avoidance
TCP slow startSlide28
28
TCP (Reno variant)
Time
Sequence No
X
X
X
X
Now what? - timeout
Packets
AcksSlide29
29
SACK
Basic problem is that cumulative acks provide little information
Selective acknowledgement (SACK)
essentially adds a bitmask of packets received
Implemented as a TCP option
Encoded as a set of received byte ranges (max of 4 ranges/often max of 3)
When to retransmit?
Still need to deal with reordering wait for out of order by 3pktsSlide30
30
Selective ACK (SACK )
Time
Sequence No
X
X
X
X
Packets
Acks
“Hole”Slide31
31
“Partial Progress ACK”
Time
Sequence No
X
X
X
X
Packets
Acks
“Hole”Slide32
32
Outline
TCP
connection setup/data transfer
Packet Loss and Retransmission
Recognizing packet loss
Identifying missing packets
Retransmission behavior
TCP congestion avoidance
TCP slow startSlide33
33
Fast Recovery
Each duplicate
ack
notifies sender that single packet has cleared network
When <
new
cwnd
packets are outstanding
Allow new packets out with each new duplicate acknowledgementBehavior
Sender is idle for some time – waiting for ½ cwnd worth of
dupacksTransmits at original rate after waitAck clocking rate is same as before lossSlide34
34
Fast Recovery
Time
Sequence No
Sent for each
dupack
after
W/2
dupacks
arrive
X
Packets
AcksSlide35
35
Performance Issues
Timeout >> fast rexmit
Need 3 dupacks/sacks
Not great for small transfers
Don’t have 3 packets outstanding
What are real loss patterns like?Slide36
36
Outline
TCP connection setup/data transfer
Packet Loss and Retransmission
TCP congestion avoidance
TCP slow startSlide37
37
Additive Increase/Decrease
T
0
T
1
Efficiency Line
Fairness Line
User 1’s Allocation
x
1
User 2’s Allocation
x
2
Both X
1
and X
2
increase/ decrease by the same amount over time
Additive increase improves fairness and additive decrease reduces fairnessSlide38
38
Muliplicative Increase/Decrease
Both X
1
and X
2
increase by the same factor over time
Extension from origin – constant fairness
T
0
T
1
Efficiency Line
Fairness Line
User 1’s Allocation
x
1
User 2’s Allocation
x
2Slide39
39
What is the Right Choice?
Constraints limit us to AIMD
Improves or keeps fairness constant at each step
AIMD moves towards optimal point
x
0
x
1
x
2
Efficiency Line
Fairness Line
User 1’s Allocation
x
1
User 2’s Allocation
x
2Slide40
40
TCP Congestion Control
Changes to TCP motivated by ARPANET congestion collapse
Basic principles
AIMD
Packet conservation
Reaching steady state quickly
ACK clockingSlide41
41
AIMD
Distributed, fair and efficient
Packet loss is seen as sign of congestion and results in a multiplicative rate decrease
Factor of 2
TCP periodically probes for available bandwidth by increasing its rate
Time
RateSlide42
42
Implementation Issue
Operating system timers are very coarse – how to pace packets out smoothly?
Implemented using a congestion window that limits how much data can be in the network.
TCP also keeps track of how much data is in transit
Data can only be sent when the amount of outstanding data is less than the congestion window.
The amount of outstanding data is increased on a “send” and decreased on “ack”
(last sent – last acked) < congestion window
Window limited by both congestion and buffering
Sender’s maximum window = Min (advertised window, cwnd)Slide43
43
Packet Conservation
At equilibrium, inject packet into network only when one is removed
Sliding window and not rate controlled
But still need to avoid sending burst of packets
would overflow links
Need to carefully pace out packets
Helps provide stability
Need to e
liminate spurious retransmissions
Accurate RTO estimation
Better loss recovery techniques (e.g. fast retransmit)Slide44
44
Congestion window helps to “pace” the transmission of data packets
In steady state, a packet is sent when an ack is received
Data transmission remains smooth, once it is smooth
Self-clocking behavior
P
r
P
b
A
r
A
b
Receiver
Sender
A
s
TCP Packet PacingSlide45
45
Window, Rate, Packet Pacing
Time
Sequence No
Packets
cwnd
rttSlide46
46
Congestion Avoidance
If loss occurs when cwnd = W
Network can handle 0.5W ~ W segments
Set cwnd to 0.5W (multiplicative decrease)
Upon receiving ACK
Increase cwnd by (1 packet)/cwnd
What is 1 packet?
1 MSS worth of bytes
After cwnd packets have passed by
approximately increase of 1 MSS
Implements AIMDSlide47
47
Congestion Avoidance Sequence Plot
Time
Sequence No
Packets
Acks
8
9
10Slide48
48
Congestion Avoidance Behavior
Time
Congestion
Window
Packet loss
+ retransmit
Grabbing
back
Bandwidth
Cut
Congestion
Window
and RateSlide49
49
How to Change Window
When a loss occurs have W packets outstanding
New cwnd = 0.5 * cwnd
How to get to new state without losing ack clocking?Slide50
50
Outline
TCP connection setup/data transfer
Packet Loss and Retransmission
TCP congestion avoidance
TCP slow startSlide51
51
Reaching Steady State
Doing AIMD is fine in steady state but slow…
How does TCP know what is a good initial rate to start with?
Should work both for a CDPD (10s of Kbps or less) and for supercomputer links (10
Gbps
and growing)
Quick initial phase to help get up to speed
Called “slow start” – Why?Slide52
52
Slow Start Packet Pacing
How do we get this clocking behavior to start?
Initialize cwnd = 1
Upon receipt of every ack, cwnd = cwnd + 1
Implications
Window actually increases to W in RTT * log
2
(W)
Can overshoot window and cause packet lossSlide53
53
Slow Start Example
1
One RTT
One pkt time
0R
2
1R
3
4
2R
5
6
7
8
3R
9
10
11
12
13
14
15
1
2
3
4
5
6
7Slide54
54
Slow Start Sequence Plot
Time
Sequence No
.
.
.
Packets
AcksSlide55
55
Return to Slow Start
If packet is lost we lose our self clocking as well
Need to implement slow-start and congestion avoidance together
When retransmission occurs set ssthresh to 0.5w
If cwnd < ssthresh, use slow start
Else use congestion avoidanceSlide56
56
TCP Saw Tooth Behavior
Time
Congestion
Window
Initial
Slowstart
Fast
Retransmit
and Recovery
Slowstart
to pace
packets
Timeouts
may still
occur
ssthreshSlide57
57
Important Lessons
TCP state diagram
setup/teardown
TCP timeout calculation
how is RTT estimated
Modern TCP loss recovery
Why are timeouts bad?
How to avoid them?
e.g. fast retransmit