Part I: Introduction by gioAqGh

VIEWS: 0 PAGES: 35

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


          point-to-point:                                 full duplex data:
             one sender, one receiver                        bi-directional data flow

          reliable, in-order         byte                     in same connection
                                                              MSS: maximum segment
             steam:
                                                               size
                    no “message boundaries”
                                                           connection-oriented:
          pipelined:
                                                              handshaking (exchange
             TCP congestion and flow
                                                               of control msgs) init’s
              control set window size                          sender, receiver state
            send & receive buffers                            before data exchange
                                                             flow controlled:
                                                                sender will not
             application               application
             writes data               reads data
socket                                                  socket

                                                                 overwhelm receiver
 door                                                    door
                TCP                       TCP
             send buffer              receive buffer
                            segment

                                                                        3: Transport Layer   3b-1
   TCP segment structure
                                      32 bits
  URG: urgent data                                                     counting
(generally not used)    source port #          dest port #
                                                                       by bytes
                               sequence number                         of data
       ACK: ACK #
             valid         acknowledgement number                      (not segments!)
                       head not
PSH: push data now      len used
                                 UA P R S F   rcvr window size
(generally not used)                                                       # bytes
                           checksum            ptr urgent data
                                                                           rcvr willing
    RST, SYN, FIN:                                                         to accept
                           Options (variable length)
   connection estab
   (setup, teardown
         commands)
                                     application
           Internet                     data
          checksum                (variable length)
        (as in UDP)


                                                                 3: Transport Layer   3b-2
 TCP seq. #’s and ACKs
Seq. #’s:
                                        Host A           Host B
     byte stream
      “number” of first       User
                              types
      byte in segment’s         ‘C’
      data                                                      host ACKs
                                                                receipt of
ACKs:                                                           ‘C’, echoes
     seq # of next byte                                          back ‘C’
      expected from
      other side            host ACKs
     cumulative ACK         receipt
                            of echoed
Q: how receiver handles         ‘C’
   out-of-order segments
     A: TCP spec doesn’t
                                                                           time
      say, - up to
                                            simple telnet scenario
      implementor
                                                      3: Transport Layer   3b-3
TCP: reliable data transfer

                                      simplified sender, assuming
 event: data received
from application above
 create, send segment                      •one way data transfer
                                           •no flow, congestion control


               event: timer timeout for
  wait
   wait
   for          segment with seq # y
  for
  event
 event           retransmit segment




 event: ACK received,
    with ACK # y
   ACK processing

                                                       3: Transport Layer   3b-4
TCP:         00 sendbase = initial_sequence number
             01 nextseqnum = initial_sequence number


reliable
             02
             03 loop (forever) {
             04   switch(event)


data
             05   event: data received from application above
             06       create TCP segment with sequence number nextseqnum
             07       start timer for segment nextseqnum


transfer
             08       pass segment to IP
             09       nextseqnum = nextseqnum + length(data)
             10    event: timer timeout for segment with sequence number y
             11       retransmit segment with sequence number y
             12       compue new timeout interval for segment y
Simplified   13       restart timer for sequence number y
             14    event: ACK received, with ACK field value of y
TCP          15       if (y > sendbase) { /* cumulative ACK of all data up to y */
sender       16           cancel all timers for segments with sequence numbers < y
             17            sendbase = y
             18            }
             19       else { /* a duplicate ACK for already ACKed segment */
             20            increment number of duplicate ACKs received for y
             21            if (number of duplicate ACKS received for y == 3) {
             22                /* TCP fast retransmit */
             23               resend segment with sequence number y
             24               restart timer for segment y
             25           }
             26   } /* end of loop forever */
                                                          3: Transport Layer    3b-5
TCP ACK generation                      [RFC 1122, RFC 2581]


Event                               TCP Receiver action
in-order segment arrival,           delayed ACK. Wait up to 500ms
no gaps,                            for next segment. If no next segment,
everything else already ACKed       send ACK

in-order segment arrival,           immediately send single
no gaps,                            cumulative ACK
one delayed ACK pending

out-of-order segment arrival        send duplicate ACK, indicating seq. #
higher-than-expect seq. #           of next expected byte
gap detected

arrival of segment that             immediate ACK if segment starts
partially or completely fills gap   at lower end of gap

                                                        3: Transport Layer   3b-6
  TCP: retransmission scenarios
            Host A       Host B                         Host A           Host B




                                       Seq=92 timeout
                                  Seq=100 timeout
  timeout




                     X
                 loss




time                              time                   premature timeout,
              lost ACK scenario
                                                          cumulative ACKs

                                                                 3: Transport Layer   3b-7
   TCP Flow Control
        flow control                         receiver: explicitly
         sender won’t overrun                   informs sender of
         receiver’s buffers by                  (dynamically changing)
        transmitting too much,                  amount of free buffer
                too fast                        space
                                                  RcvWindow field in
RcvBuffer = size or TCP Receive Buffer              TCP segment
RcvWindow = amount of spare room in Buffer   sender: keeps the amount
                                                of transmitted,
                                                unACKed data less than
                                                most recently received
                                                RcvWindow



             receiver buffering
                                                       3: Transport Layer   3b-8
TCP Round Trip Time and Timeout
Q: how to set TCP           Q: how to estimate RTT?
  timeout value?             SampleRTT: measured time from
 longer than RTT             segment transmission until ACK
                              receipt
     note: RTT will vary
                                ignore retransmissions,
 too short: premature
                                 cumulatively ACKed segments
  timeout
                             SampleRTT will vary, want
    unnecessary
                              estimated RTT “smoother”
      retransmissions
                                use several recent
 too long: slow reaction
                                 measurements, not just
  to segment loss
                                 current SampleRTT




                                             3: Transport Layer   3b-9
TCP Round Trip Time and Timeout
EstimatedRTT = (1-x)*EstimatedRTT + x*SampleRTT
      Exponential weighted moving average
      influence of given sample decreases exponentially fast
      typical value of x: 0.1


Setting the timeout
 EstimtedRTT plus “safety margin”
 large variation in EstimatedRTT -> larger safety margin

       Timeout = EstimatedRTT + 4*Deviation
    Deviation = (1-x)*Deviation +
                 x*|SampleRTT-EstimatedRTT|


                                               3: Transport Layer 3b-10
TCP Connection Management

Recall: TCP sender, receiver      Three way handshake:
  establish “connection”
  before exchanging data          Step 1: client end system
  segments                          sends TCP SYN control
 initialize TCP variables:         segment to server
    seq. #s                          specifies initial seq #

    buffers, flow control
                                  Step 2: server end system
      info (e.g. RcvWindow)
                                    receives SYN, replies with
 client: connection initiator      SYNACK control segment
    Socket clientSocket = new
     Socket("hostname","port            ACKs received SYN
    number");                           allocates buffers
   server: contacted by client         specifies server->
    Socket connectionSocket =            receiver initial seq. #
     welcomeSocket.accept();
                                                    3: Transport Layer 3b-11
TCP Connection Management (cont.)

Closing a connection:                         client       server

                               close
client closes socket:
    clientSocket.close();

Step 1: client end system                                            close
  sends TCP FIN control
  segment to server

Step 2: server receives
  FIN, replies with ACK.         timed wait
  Closes connection, sends
  FIN.                       closed


                                                       3: Transport Layer 3b-12
TCP Connection Management (cont.)

Step 3: client receives FIN,                    client       server
  replies with ACK.             closing
      Enters “timed wait” -
       will respond with ACK
       to received FINs
                                                                        closing
Step 4: server, receives
  ACK. Connection closed.


                                   timed wait
Note: with small
                                                                        closed
  modification, can handly
  simultaneous FINs.
                               closed


                                                         3: Transport Layer 3b-13
TCP Connection Management (cont)



                           TCP server
                           lifecycle


TCP client
lifecycle




                         3: Transport Layer 3b-14
Principles of Congestion Control

Congestion:
 informally: “too many sources sending too much
  data too fast for network to handle”
 different from flow control!
 manifestations:
    lost packets (buffer overflow at routers)
    long delays (queueing in router buffers)
 a top-10 problem!




                                         3: Transport Layer 3b-15
 Causes/costs of congestion: scenario 1
 two senders, two
  receivers
 one router,
  infinite buffers
 no retransmission



                              large delays
                               when congested
                              maximum
                               achievable
                               throughput
                                3: Transport Layer 3b-16
 Causes/costs of congestion: scenario 2

 one router,   finite buffers
 sender retransmission of lost packet




                                         3: Transport Layer 3b-17
Causes/costs of congestion: scenario 2
 always:   l= l     (goodput)
           in    out
 “perfect” retransmission only when loss:   l > lout
                                               in
   retransmission of delayed (not lost) packet makes l       larger
                                                        in
    (than perfect case) for same  lout




“costs” of congestion:
 more work (retrans) for given “goodput”
 unneeded retransmissions: link carries multiple copies of pkt
                                                    3: Transport Layer 3b-18
Causes/costs of congestion: scenario 3
 four senders
                       Q: what happens as l
 multihop paths                            in
                         and l increase ?
 timeout/retransmit           in




                                     3: Transport Layer 3b-19
Causes/costs of congestion: scenario 3




Another “cost” of congestion:
 when packet dropped, any “upstream transmission
  capacity used for that packet was wasted!

                                       3: Transport Layer 3b-20
Approaches towards congestion control
Two broad approaches towards congestion control:

 End-end congestion            Network-assisted
   control:                      congestion control:
  no explicit feedback from    routers provide feedback
   network                       to end systems
  congestion inferred from        single bit indicating
   end-system observed loss,         congestion (SNA,
   delay                             DECbit, TCP/IP ECN,
  approach taken by TCP             ATM)
                                   explicit rate sender
                                     should send at



                                               3: Transport Layer 3b-21
Case study: ATM ABR congestion control

ABR: available bit rate:    RM (resource management)
 “elastic service”           cells:
 if sender’s path           sent by sender, interspersed
  “underloaded”:              with data cells
    sender should use       bits in RM cell set by switches
      available bandwidth     (“network-assisted”)
 if sender’s path              NI bit: no increase in rate
  congested:                      (mild congestion)
    sender throttled to        CI bit: congestion
      minimum guaranteed          indication
      rate                   RM cells returned to sender by
                              receiver, with bits intact


                                            3: Transport Layer 3b-22
Case study: ATM ABR congestion control




 two-byte ER (explicit rate) field in RM cell
    congested switch may lower ER value in cell
    sender’ send rate thus minimum supportable rate on path

 EFCI bit in data cells: set to 1 in congested switch
    if data cell preceding RM cell has EFCI set, sender sets CI
     bit in returned RM cell

                                                  3: Transport Layer 3b-23
TCP Congestion Control
 end-end control (no network assistance)
 transmission rate limited by congestion window
  size, Congwin, over segments:




         Congwin


 w segments, each with MSS bytes sent in one RTT:

                         w * MSS
          throughput =           Bytes/sec
                          RTT


                                             3: Transport Layer 3b-24
TCP congestion control:
 “probing” for usable              two “phases”
  bandwidth:                           slow start
      ideally: transmit as fast       congestion avoidance
       as possible (Congwin as
                                    important variables:
       large as possible)
                                      Congwin
       without loss
                                      threshold: defines
      increase Congwin until
       loss (congestion)               threshold between two
                                       slow start phase,
      loss: decrease Congwin,
                                       congestion control
       then begin probing
                                       phase
       (increasing) again




                                                   3: Transport Layer 3b-25
TCP Slowstart
                                      Host A          Host B
Slowstart algorithm




                                RTT
initialize: Congwin = 1
for (each segment ACKed)
     Congwin++
until (loss event OR
       CongWin > threshold)

 exponential increase (per
  RTT) in window size (not so
  slow!)                                                       time
 loss event: timeout (Tahoe
  TCP) and/or or three
  duplicate ACKs (Reno TCP)
                                               3: Transport Layer 3b-26
TCP Congestion Avoidance
Congestion avoidance
 /* slowstart is over   */
 /* Congwin > threshold */
 Until (loss event) {
   every w segments ACKed:
      Congwin++
   }
 threshold = Congwin/2
 Congwin = 1
                    1
 perform slowstart

1: TCP Reno skips slowstart (fast
recovery) after three duplicate ACKs
                                       3: Transport Layer 3b-27
AIMD
                               TCP Fairness
TCP congestion
  avoidance:                    Fairness goal: if N TCP
 AIMD: additive                  sessions share same
  increase,                       bottleneck link, each
  multiplicative                  should get 1/N of link
  decrease                        capacity
     increase window by 1       TCP connection 1
      per RTT
     decrease window by
      factor of 2 on loss
      event
                                             bottleneck
                             TCP
                                               router
                             connection 2
                                             capacity R

                                                    3: Transport Layer 3b-28
Why is TCP fair?
Two competing sessions:
 Additive increase gives slope of 1, as throughout increases
 multiplicative decrease decreases throughput proportionally

            R               equal bandwidth share




                                loss: decrease window by factor of 2
                                congestion avoidance: additive increase
                                     loss: decrease window by factor of 2
                                   congestion avoidance: additive increase




                Connection 1 throughput R

                                                        3: Transport Layer 3b-29
  TCP latency modeling
Q: How long does it take to Notation, assumptions:
  receive an object from a  Assume one link between
  Web server after sending    client and server of rate R
  a request?                 Assume: fixed congestion
 TCP connection establishment       window, W segments
 data transfer delay               S: MSS (bits)
                                    O: object size (bits)
                                    no retransmissions (no loss,
                                     no corruption)
         Two cases to consider:
          WS/R > RTT + S/R: ACK for first segment in
           window returns before window’s worth of data
           sent
          WS/R < RTT + S/R: wait for ACK after sending
           window’s worth of data sent           3: Transport Layer   3b-30
TCP latency Modeling                      K:= O/WS




Case 1: latency = 2RTT + O/R   Case 2: latency = 2RTT + O/R
                                + (K-1)[S/R + RTT - WS/R]


                                            3: Transport Layer 3b-31
  TCP Latency Modeling: Slow Start
   Now suppose window grows according to slow start.
   Will show that the latency of one object of size O is:

                       O           S              S
   Latency  2 RTT       P  RTT    ( 2 P  1)
                       R           R              R

     where P is the number of times TCP stalls at server:

                 P  min{Q, K  1}

- where Q is the number of times the server would stall
  if the object were of infinite size.

- and K is the number of windows that cover the object.




                                                          3: Transport Layer 3b-32
   TCP Latency Modeling: Slow Start (cont.)
                           initiate TCP

Example:
                            connection


                             request
O/S = 15 segments             object
                                                                   first window
                                                                       = S/R

K = 4 windows                       RTT
                                                                   second window
                                                                       = 2S/R
Q=2
                                                               third window
                                                                  = 4S/R
P = min{K-1,Q} = 2

Server stalls P=2 times.
                                                                   fourth window
                                                                      = 8S/R




                                                                     complete
                            object                                 transmission
                           delivered
                                                         time at
                                          time at        server
                                           client

                                                    3: Transport Layer 3b-33
          TCP Latency Modeling: Slow Start (cont.)
 S
    RTT  time from when server starts to send segment
 R
           until server receives acknowledgement
                                                  initiate TCP
                                                   connection

         S
 2k 1      time to transmit the kth window        request
         R                                           object
                                                                                                    first window
                                                                                                        = S/R

                     
S              S                                         RTT
                                                                                                    second window

R  RTT  2k 1   stall time after the kth window                                                    = 2S/R
               R
                                                                                                third window
                                                                                                   = 4S/R



                     P
         O
latency   2 RTT   stallTimep
                                                                                                    fourth window
                                                                                                       = 8S/R
         R          p 1
                       P
           O               S              S
            2 RTT   [  RTT  2 k 1 ]
           R          k 1 R              R        object
                                                                                                      complete
                                                                                                    transmission
                                                  delivered
           O                  S               S
            2 RTT  P[ RTT  ]  ( 2 P  1)                    time at
                                                                                          time at
                                                                                          server
           R                  R               R                   client

                                                                           3: Transport Layer 3b-34
Chapter 3: Summary

 principles behind
  transport layer services:
     multiplexing/demultiplexing   Next:
    reliable data transfer          leaving the network
    flow control
                                      “edge” (application
                                      transport layer)
    congestion control
                                     into the network “core”
 instantiation and
  implementation in the Internet
    UDP
    TCP




                                               3: Transport Layer 3b-35

								
To top