Transport Layer

Transport layer handles reliability and is end-to-end

Basics

Reliability Principles

Correctness

1. All packets should be delivered (if not, inform the application about failure)
2. No duplicates to be delivered
3. Packets are delivered in order

Performance

1. Low latency / high throughput
2. Respect memory constraints of receiver
3. Fairness

Sources of Error

Bit Error

1. Noise
2. Interference
3. Fading

Packet Loss due to Congestion

• No more memory to accept the next packet in queue, hence drop it

Bottleneck Bandwidth

Bottleneck Bandwidth: smallest bandwidth among the links through routers that limits the data rate from the server

• Calculating bottleneck bandwidth: $\frac{L}{T-t}$
• 
• Package injection (in between $P_1$ and $P_2$) $\to$ will cause the value to be overestimated
• Backlog queue $\to$ will cause the value to be underestimated ($P_1$ waits in a queue while $P_2$ catches up)
• So we want to do multiple trials and take the max (or 95%)

Available Bandwidth $\ne$ bottleneck bandwidth / number of flows through bottleneck link

• There might be more number of flows through another link (even if that link bandwidth is larger)

Reliable Transfer Protocol Design

1. No error at all
2. Bit errors in the packets
   • NACK $\to$ resend the packet
   • ACK $\to$ send next packet

$b{t}_{[n+1:n+m]}=f(b{t}_{[1:n]})$

When receiver receives $b{r}_{[1:n+m]}$, it separates out the last $m$ bits and checks if $b{r}_{[n+1:n+m]}=f(b{r}_{[1:n]})$

• Error detection code
• Error correction code

Dealing with Various Errors

Bit Error

• Error when sending NACK is not a problem
• Error when sending ACK causes duplication
• Solution: introduce sequence # in packets in transport layer header
  • Keep 1 bit
  • Alternate every time

Bit Error + Packet Loss

• Wait for a while (timeout (T/O)), if an ACK packet does not come then re-transmit
  • TCP Protocol uses a single timer for timeouts

Bit Error + Packet Loss + Delay

• Increase available sequence numbers so that they don't wrap in the same sender to receiver session
• Estimate the max Round Trip Time (RTT) from sender S to receiver R
• $\text{Max Sequence No.}\ge \text{Max RTT}/\text{Sender Transmit Time}$

Efficiency & Pipelining

Efficiency

• $\text{Efficiency}=\text{Transmit Time}/\text{RTT}$
• For max efficiency, the sender must send no more than $N$ packets until the first ACK returns
  $N=\text{RTT}/\text{Max Transmit Time}$

Pipelining

• The number of unacknowledged packets that we can have
  Sender can send $N$ packets without an ACK from the receiver
• $\text{Max efficiency}=1$
  $\text{Max throughput}=\frac{N\cdot L}{\text{RTT}}$
  where $N=\text{RTT}/\text{Max Transmit Time}$

Pipelining Protocols

Sliding Window Protocols

(An example of $N=4$)

Go Back N (GBN)

Transmit $N$ packets and keep moving $T_x$ window. Upon timeout, re-transmit all $N$ packets in the current window.

1. Receiver $R_x$ has no buffer and drops out-of-order packets
2. Transmitter $T_x$ uses a fixed $N$
3. Receiver $R_x$ sends in-order cumulative ACK
4. Transmitter $T_x$ resends all $N$ packets upon timeout or lost packet

Example

Selective ACK (SACK)

For packet $P_x$, receiver must send $A_x$ only if $x\ge B-N$, with $B$ being the receiver window base and $N$ being the window size.

1. $R_x$ can buffer $N$ out-of-order packets
2. $R_x$ also have a window
3. $R_x$ will only ACK packets that has been received (not cumulative)
4. $T_x$ will re-transmit the packet for which it has timed out
5. $T_x$ will only re-transmit the packets that have timed out

Window Size

We want to pick the correct window size $N$ to keep the available/bottleneck router always occupied.
The available bandwidth is constantly changing
$\to$ $N$ must be time varying
$\to$ $N=f(\text{RTT})$
$\to$ we call this Congestion Window