chapter 3: transport layer transport layernikita/courses/ece438-fa06/slides/cs438-16... ·...

1

1

Transport Layer

2

Chapter 3: Transport Layer

Our goals: understand

principles behindtransport layerservices: multiplexing/

demultiplexing reliable data

transfer flow control congestion control

learn about transportlayer protocols in theInternet: UDP: connectionless

transport TCP: connection-

oriented transport TCP congestion control

3

Chapter 3 outline 3.1 Transport-layer

services 3.2 Multiplexing and

demultiplexing 3.3 Connectionless

transport: UDP 3.4 Principles of

reliable data transfer

3.5 Connection-orientedtransport: TCP segment structure reliable data transfer flow control connection management

3.6 Principles ofcongestion control

3.7 TCP congestioncontrol

4

Transport services and protocols

provide logicalcommunication between appprocesses running ondifferent hosts

transport protocols run in endsystems send side: breaks app

messages into segments,passes to network layer

rcv side: reassemblessegments into messages,passes to app layer

more than one transportprotocol available to apps Internet: TCP and UDP

application

transportnetworkdata linkphysical

application


networkdata linkphysical



networkdata linkphysicalnetwork

data linkphysical

logical end-end transport

5

Transport vs. network layer network layer:

logicalcommunicationbetween hosts

transport layer:logicalcommunicationbetween processes relies on, enhances,

network layerservices

Household analogy:sending letters processes = people app messages = letters

in envelopes hosts = houses transport protocol =

sorting and collectingmail within house

network-layer protocol= postal service

6

Internet transport-layer protocols reliable, in-order

delivery (TCP) congestion control flow control connection setup

unreliable, unordereddelivery: UDP no-frills extension of

“best-effort” IP

services not available: delay guarantees bandwidth guarantees

application


application





networkdata linkphysicalnetwork

data linkphysical

logical end-end transport

2

7









8

Multiplexing/demultiplexing

application

transport

network

link

physical

P1 application

transport

network

link

physical

application

transport

network

link

physical

P2P3 P4P1

host 1 host 2 host 3

= process= socket

delivering received segmentsto correct socket

Demultiplexing at rcv host:gathering data from multiplesockets, enveloping data with header (later used for demultiplexing)

Multiplexing at send host:

9

How demultiplexing works host receives IP datagrams

each datagram hassource IP address,destination IP address

each datagram carries 1transport-layer segment

each segment hassource, destination portnumber

host uses IP addresses & portnumbers to direct segment toappropriate socket

source port # dest port #

32 bits

applicationdata

(message)

other header fields

TCP/UDP segment format

10

Connectionless demultiplexing Create sockets with port

numbers:sin1.sin_port = 1234;

bind(socket1, &sin1, …);

sin2.sin_port = 1235;

bind(socket2, &sin2, …);

UDP socket identified bytwo-tuple:

(dest IP address, dest port number)

When host receivesUDP segment: checks destination port

number in segment directs UDP segment to

socket with that portnumber

IP datagrams withdifferent source IPaddresses and/or sourceport numbers directed tosame socket

11

Connectionless demux (cont)

sin.sin_port = 6428; bind(sock, &sin, …);

ClientIP:B

P2

client IP: A

P1P1P3

serverIP: C

SP: 6428DP: 9157

SP: 9157DP: 6428

SP: 6428DP: 5775

SP: 5775DP: 6428

SP provides “return address”(returned by recvfrom)

12

Connection-oriented demux

TCP socketidentified by 4-tuple: source IP address source port number dest IP address dest port number

recv host uses allfour values to directsegment toappropriate socket

Server host may supportmany simultaneous TCPsockets: each socket identified by

its own 4-tuple

Web servers havedifferent sockets foreach connecting client non-persistent HTTP will

have different socket foreach request

3

13

Connection-oriented demux (cont)

ClientIP:B

P1

client IP: A

P1P2P4

serverIP: C

SP: 9157DP: 80

SP: 9157DP: 80

P5 P6 P3

D-IP:CS-IP: AD-IP:C

S-IP: B

SP: 5775DP: 80

D-IP:CS-IP: B

14

Connection-oriented demux:Threaded Web Server

ClientIP:B

P1

client IP: A

P1P2

serverIP: C

SP: 9157DP: 80

SP: 9157DP: 80

P4 P3

D-IP:CS-IP: AD-IP:C

S-IP: B

SP: 5775DP: 80

D-IP:CS-IP: B

15









16

UDP: User Datagram Protocol [RFC 768]

“no frills,” “bare bones”Internet transport protocol

“best effort” service, UDPsegments may be: lost delivered out of order

to app connectionless:

no handshakingbetween UDP sender,receiver

each UDP segmenthandled independentlyof others

Why is there a UDP? no connection

establishment (whichcan add delay)

simple: no connectionstate at sender, receiver

small segment header no congestion control:

UDP can blast away asfast as desired

17

UDP: more often used for

streaming multimediaapps loss tolerant rate sensitive

other UDP uses DNS SNMP

reliable transfer overUDP: add reliability atapplication layer application-specific

error recovery!


32 bits

Applicationdata

(message)

UDP segment format

length checksumLength, in

bytes of UDPsegment,including

header

18

UDP checksum

Sender: treat segment

contents as sequenceof 16-bit integers

checksum: addition(1’s complement sum)of segment contents

sender putschecksum value intoUDP checksum field

Receiver: compute checksum of

received segment check if computed checksum

equals checksum field value: NO - error detected YES - no error detected.

But maybe errorsnonetheless? More later….

Goal: detect “errors” (e.g., flipped bits) in transmittedsegment

4

19









20

Principles of Reliable datatransfer

important in app., transport, link layers top-10 list of important networking topics!

characteristics of unreliable channel will determinecomplexity of reliable data transfer protocol (rdt)

21

Principles of Reliable datatransfer important in app., transport, link layers top-10 list of important networking topics!


22

Principles of Reliable datatransfer important in app., transport, link layers top-10 list of important networking topics!


23

Reliable data transfer: getting started

sendside

receiveside

rdt_send(): called from above, (e.g.,by app.). Passed data to

deliver to receiver upper layer

udt_send(): called by rdt,to transfer packet over

unreliable channel to receiver

rdt_rcv(): called when packetarrives on rcv-side of channel

deliver_data(): called by rdtto deliver data to upper

24

Reliable data transfer: getting startedWe’ll: incrementally develop sender, receiver sides of

reliable data transfer protocol (rdt) consider only unidirectional data transfer

but control info will flow on both directions! use finite state machines (FSM) to specify

sender, receiver

state1

state2

event causing state transitionactions taken on state transition

state: when in this“state” next state

uniquely determined bynext event

eventactions

5

25

Rdt1.0: reliable transfer over a reliable channel

underlying channel perfectly reliable no bit errors no loss of packets

separate FSMs for sender, receiver: sender sends data into underlying channel receiver read data from underlying channel

Wait forcall fromabove packet = make_pkt(data)

udt_send(packet)

rdt_send(data)extract (packet,data)deliver_data(data)

Wait forcall from

below

rdt_rcv(packet)

sender receiver26

Rdt2.0: channel with bit errors underlying channel may flip bits in packet

checksum to detect bit errors the question: how to recover from errors:

acknowledgements (ACKs): receiver explicitly tells senderthat pkt received OK

negative acknowledgements (NAKs): receiver explicitly tellssender that pkt had errors

sender retransmits pkt on receipt of NAK new mechanisms in rdt2.0 (beyond rdt1.0):

error detection receiver feedback: control msgs (ACK,NAK) rcvr->sender

27

rdt2.0: FSM specification

Wait forcall fromabove

snkpkt = make_pkt(data, checksum)udt_send(sndpkt)

extract(rcvpkt,data)deliver_data(data)udt_send(ACK)

rdt_rcv(rcvpkt) && notcorrupt(rcvpkt)

rdt_rcv(rcvpkt) && isACK(rcvpkt)

udt_send(sndpkt)

rdt_rcv(rcvpkt) && isNAK(rcvpkt)

udt_send(NAK)

rdt_rcv(rcvpkt) && corrupt(rcvpkt)

Wait forACK or

NAK

Wait forcall from

belowsender

receiverrdt_send(data)

L

28

rdt2.0: operation with no errors






udt_send(sndpkt)


udt_send(NAK)


Wait forACK or

NAK

Wait forcall from

below

rdt_send(data)

Λ

29

rdt2.0: error scenario






udt_send(sndpkt)


udt_send(NAK)


Wait forACK or

NAK

Wait forcall from

below

rdt_send(data)

Λ

30

rdt2.0 has a fatal flaw!What happens if

ACK/NAKcorrupted?

sender doesn’t knowwhat happened atreceiver!

can’t just retransmit:possible duplicate

Handling duplicates: sender retransmits

current pkt if ACK/NAKgarbled

sender adds sequencenumber to each pkt

receiver discards(doesn’t deliver up)duplicate pkt

Sender sends one packet, then waits for receiver response

stop and wait

6

31

rdt2.1: sender, handles garbled ACK/NAKs

Wait forcall 0 from

above

sndpkt = make_pkt(0, data, checksum)udt_send(sndpkt)

rdt_send(data)

Wait forACK orNAK 0 udt_send(sndpkt)

rdt_rcv(rcvpkt) &&( corrupt(rcvpkt) ||isNAK(rcvpkt) )


rdt_send(data)

rdt_rcv(rcvpkt)&& notcorrupt(rcvpkt)&& isACK(rcvpkt)

udt_send(sndpkt)

rdt_rcv(rcvpkt) &&( corrupt(rcvpkt) ||isNAK(rcvpkt) )

rdt_rcv(rcvpkt)&&notcorrupt(rcvpkt)&& isACK(rcvpkt)

Wait for call 1 from

above

Wait forACK orNAK 1

ΛΛ

32

rdt2.1: receiver, handles garbled ACK/NAKs

Waitfor

0 frombelow

sndpkt = make_pkt(NAK, chksum)udt_send(sndpkt)

rdt_rcv(rcvpkt) && not corrupt(rcvpkt) && has_seq0(rcvpkt)

rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq1(rcvpkt)

extract(rcvpkt,data)deliver_data(data)sndpkt = make_pkt(ACK, chksum)udt_send(sndpkt)

Waitfor

1 frombelow

rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq0(rcvpkt)

extract(rcvpkt,data)deliver_data(data)sndpkt = make_pkt(ACK, chksum)udt_send(sndpkt)

rdt_rcv(rcvpkt) && (corrupt(rcvpkt)

sndpkt = make_pkt(ACK, chksum)udt_send(sndpkt)

rdt_rcv(rcvpkt) && not corrupt(rcvpkt) && has_seq1(rcvpkt)

rdt_rcv(rcvpkt) && (corrupt(rcvpkt)

sndpkt = make_pkt(ACK, chksum)udt_send(sndpkt)

sndpkt = make_pkt(NAK, chksum)udt_send(sndpkt)

33

rdt2.1: discussionSender: seq # added to pkt two seq. #’s (0,1) will

suffice. Why? must check if received

ACK/NAK corrupted twice as many states

state must “remember”whether “current” pkthas 0 or 1 seq. #

Receiver: must check if

received packet isduplicate state indicates

whether 0 or 1 isexpected pkt seq #

note: receiver cannot know if its lastACK/NAK receivedOK at sender

34

rdt2.2: a NAK-free protocol

same functionality as rdt2.1, using ACKs only instead of NAK, receiver sends ACK for last pkt

received OK receiver must explicitly include seq # of pkt being ACKed

duplicate ACK at sender results in same action asNAK: retransmit current pkt

35

rdt2.2: sender, receiver fragments

Wait forcall 0 from

above


rdt_send(data)

udt_send(sndpkt)

rdt_rcv(rcvpkt) &&( corrupt(rcvpkt) || isACK(rcvpkt,1) )

rdt_rcv(rcvpkt)&& notcorrupt(rcvpkt)&& isACK(rcvpkt,0)

Wait forACK

0

sender FSMfragment

Waitfor

0 frombelow

rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq1(rcvpkt)extract(rcvpkt,data)deliver_data(data)sndpkt = make_pkt(ACK1, chksum)udt_send(sndpkt)

rdt_rcv(rcvpkt) && (corrupt(rcvpkt) || has_seq1(rcvpkt))

udt_send(sndpkt)receiver FSM

fragment

L

36

rdt3.0: channels with errors and loss

New assumption:underlying channelcan also losepackets (data orACKs) checksum, seq. #,

ACKs,retransmissions willbe of help, but notenough

Approach: sender waits“reasonable” amount oftime for ACK

retransmits if no ACKreceived in this time

if pkt (or ACK) just delayed(not lost): retransmission will be

duplicate, but use of seq.#’s already handles this

receiver must specify seq# of pkt being ACKed

requires countdown timer

7

37

rdt3.0 sendersndpkt = make_pkt(0, data, checksum)udt_send(sndpkt)start_timer

rdt_send(data)

Waitfor

ACK0

rdt_rcv(rcvpkt) &&( corrupt(rcvpkt) ||isACK(rcvpkt,1) )

Wait forcall 1 from

above

sndpkt = make_pkt(1, data, checksum)udt_send(sndpkt)start_timer

rdt_send(data)

rdt_rcv(rcvpkt)&& notcorrupt(rcvpkt)&& isACK(rcvpkt,0)

rdt_rcv(rcvpkt)&&( corrupt(rcvpkt) ||isACK(rcvpkt,0) )

rdt_rcv(rcvpkt)&&notcorrupt(rcvpkt)&& isACK(rcvpkt,1)

stop_timerstop_timer

udt_send(sndpkt)start_timer

timeout

udt_send(sndpkt)start_timer

timeout

rdt_rcv(rcvpkt)

Wait forcall 0from

above

Waitfor

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ

38

rdt3.0 in action

39

rdt3.0 in action

40

Performance of rdt3.0

rdt3.0 works, but performance stinks example: 1 Gbps link, 15 ms e-e prop. delay, 1KB

packet:

T transmit = 8kb/pkt10**9 b/sec = 8 microsec

U sender: utilization – fraction of time sender busy sending

U sender

= .008

30.008 = 0.00027

microsec

onds

L / R

RTT + L / R =

L (packet length in bits)R (transmission rate, bps)

=

1KB pkt every 30 msec -> 33kB/sec thruput over 1 Gbpslinknetwork protocol limits use of physical resources!

41

rdt3.0: stop-and-wait operation

first packet bit transmitted, t = 0

sender receiver

RTT

last packet bit transmitted, t = L / R

first packet bit arriveslast packet bit arrives, sendACK

ACK arrives, send nextpacket, t = RTT + L / R

U sender

= .008

30.008 = 0.00027

microsec

onds

L / R

RTT + L / R =

42

Pipelined protocolsPipelining: sender allows multiple, “in-flight”,

yet-to-be-acknowledged pkts range of sequence numbers must be increased buffering at sender and/or receiver

Two generic forms of pipelined protocols: go-Back-N, selective repeat

8

43

Pipelining: increased utilization

first packet bit transmitted, t = 0

sender receiver

RTT

last bit transmitted, t = L / R

first packet bit arriveslast packet bit arrives, send ACK

ACK arrives, send nextpacket, t = RTT + L / R

last bit of 2nd packet arrives, send ACKlast bit of 3rd packet arrives, send ACK

U sender

= .024

30.008 = 0.0008

microsecon

ds

3 * L / R

RTT + L / R =

Increase utilizationby a factor of 3!

44

Go-Back-NSender: k-bit seq # in pkt header “window” of up to N, consecutive unack’ed pkts allowed

ACK(n): ACKs all pkts up to, including seq # n - “cumulative ACK”may receive duplicate ACKs (see receiver)

timer for each in-flight pkttimeout(n): retransmit pkt n and all higher seq # pkts in window

45

GBN: sender extended FSM

Wait start_timerudt_send(sndpkt[base])udt_send(sndpkt[base+1])…udt_send(sndpkt[nextseqnum-1])

timeout

rdt_send(data)

if (nextseqnum < base+N) { sndpkt[nextseqnum] = make_pkt(nextseqnum,data,chksum) udt_send(sndpkt[nextseqnum]) if (base == nextseqnum) start_timer nextseqnum++ }else refuse_data(data)

base = getacknum(rcvpkt)+1If (base == nextseqnum) stop_timer else start_timer


base=1nextseqnum=1


Λ

46

GBN: receiver extended FSM

ACK-only: always send ACK for correctly-received pktwith highest in-order seq # may generate duplicate ACKs need only remember expectedseqnum

out-of-order pkt: discard (don’t buffer) -> no receiver buffering! Re-ACK pkt with highest in-order seq #

Wait

udt_send(sndpkt)default

rdt_rcv(rcvpkt) && notcurrupt(rcvpkt) && hasseqnum(rcvpkt,expectedseqnum)

extract(rcvpkt,data)deliver_data(data)sndpkt = make_pkt(expectedseqnum,ACK,chksum)udt_send(sndpkt)expectedseqnum++

expectedseqnum=1sndpkt = make_pkt(expectedseqnum,ACK,chksum)

Λ

47

GBN inaction

48

Selective Repeat

receiver individually acknowledges allcorrectly received pkts buffers pkts, as needed, for eventual in-order

delivery to upper layer sender only resends pkts for which ACK

not received sender timer for each unACKed pkt

sender window N consecutive seq #’s again limits seq #s of sent, unACKed pkts

9

49

Selective repeat: sender, receiver windows

50

Selective repeatdata from above : if next available seq #

in window, send pkttimeout(n): resend pkt n, restart

timerACK(n) in

[sendbase,sendbase+N]:

mark pkt n as received if n smallest unACKed

pkt, advance windowbase to next unACKedseq #

senderpkt n in [rcvbase, rcvbase+N-1]send ACK(n)out-of-order: bufferin-order: deliver (also deliverbuffered, in-order pkts), advancewindow to next not-yet-receivedpktpkt n in [rcvbase-N,rcvbase-1]ACK(n)otherwise:ignore

receiver

51

Selective repeat in action

52

Selective repeat: dilemma

Example: seq #’s: 0, 1, 2, 3 window size=3

receiver sees nodifference in twoscenarios!

incorrectly passesduplicate data as newin (a)

Q: what relationshipbetween seq # sizeand window size?

53









54

TCP: Overview RFCs: 793, 1122, 1323, 2018, 2581

full duplex data: bi-directional data flow

in same connection MSS: maximum

segment size

connection-oriented: handshaking (exchange

of control msgs) init’ssender, receiver statebefore data exchange

flow controlled: sender will not

overwhelm receiver

point-to-point: one sender, one receiver

reliable, in-order bytesteam: no “message boundaries”

pipelined: TCP congestion and flow

control set window size send & receive buffers

socket

door

TCP

send buffer

TCP

receive buffer

socket

door

segment

application

writes data

application

reads data

10

55

TCP segment structure


32 bits

applicationdata

(variable length)

sequence numberacknowledgement number

Receive window

Urg data pnterchecksumFSRPAUhead

lennot

used

Options (variable length)

URG: urgent data (generally not used)

ACK: ACK #valid

PSH: push data now(generally not used)

RST, SYN, FIN:connection estab(setup, teardown

commands)

# bytes rcvr willingto accept

countingby bytes of data(not segments!)

Internetchecksum

(as in UDP)

56

TCP seq. #’s and ACKsSeq. #’s:

byte stream“number” of firstbyte in segment’sdata

ACKs: seq # of next byte

expected fromother side

cumulative ACKQ: how receiver handles

out-of-order segments A: TCP spec

doesn’t say, - upto implementor

Host A Host B

Seq=42, ACK=79, data = ‘C’

Seq=79, ACK=43, data = ‘C’

Seq=43, ACK=80

Usertypes

‘C’

host ACKsreceipt

of echoed‘C’

host ACKsreceipt of

‘C’, echoesback ‘C’

timesimple telnet scenario

57

TCP Round Trip Time and TimeoutQ: how to set TCP

timeout value? longer than RTT

but RTT varies

too short:premature timeout unnecessary

retransmissions too long: slow

reaction tosegment loss

Q: how to estimate RTT? SampleRTT: measured

time from segmenttransmission until ACKreceipt ignore retransmissions

SampleRTT will vary, wantestimated RTT “smoother” average several recent

measurements, not justcurrent SampleRTT

58

TCP Round Trip Time and TimeoutEstimatedRTT = (1- α)*EstimatedRTT + α*SampleRTT

Exponential weighted moving averageinfluence of past sample decreases exponentially fasttypical value: α = 0.125

chapter 3: transport layer transport layernikita/courses/ece438-fa06/slides/cs438-16... ·...

Documents