RTT, bandwidth-delay product, utilisation and a = Tp/Tt

1. 5 packets, 3 equal links, T_t = 2 ms, T_p = 1 ms: total?
   Stuck? Peek at 1.3.2 Propagation, queuing and processing delay; multi-hop pipelining

   • T_p = d / v, v = 2 × 10⁸ m/s default; independent of size and rate.
   • Nodal delay = d_proc + d_queue + T_t + T_p.
   • One packet, h equal links: h·T_t + h·T_p.
   • N packets, h equal links: (N + h − 1)·T_t + h·T_p (+ (h − 1)·d_proc).
   • Unequal links: first packet ΣT_t + ΣT_p, then + (N − 1) × max T_t.
   • Traffic intensity L·a/R → 1: queues explode.

   Read lesson 1.3.2

2. Throughput of a path with links 50, 10 and 100 Mbps is at most?
   Stuck? Peek at 1.3.1 Bandwidth, data rate, throughput and transmission delay

   • Bandwidth / data rate B = link capacity in bps (decimal prefixes).
   • T_t = L / B (L in bits) — independent of distance.
   • Throughput = bits delivered / time ≤ min link rate on the path (bottleneck).

   Read lesson 1.3.1

3. (1 − 1/n)ⁿ tends to?
   Stuck? Peek at 0.2.4 Exponents, logarithms and basic probability

   • 2ᵃ·2ᵇ = 2ᵃ⁺ᵇ; 2¹⁰ ≈ 10³ (estimates only).
   • log₂ x = power of 2 giving x; bits for N values = ⌈log₂ N⌉.
   • P(none) = (1−p)ⁿ · P(≥ 1) = 1 − (1−p)ⁿ · P(exactly 1) = n·p·(1−p)ⁿ⁻¹.
   • (1 − 1/n)ⁿ → 1/e ≈ 0.368; 1/(2e) ≈ 0.184.
   • 1 + 2 + … + 2ᵏ⁻¹ = 2ᵏ − 1; expected tries = 1/p.

   Read lesson 0.2.4

Imagine a pipe from Delhi to Chennai filled with ping-pong balls. Even with the tap fully open, the first ball needs time to reach the far end, and the pipe itself holds many balls in transit. A sender that pushes one ball and then waits for a "got it" shout back leaves the pipe almost empty most of the time. This lesson measures that emptiness.

A 1 Gbps link has a one-way propagation delay of 10 ms. How many bits are travelling inside the link at the moment the first bit arrives at the far end?

10⁷ bits (10 million). In 10 ms the sender pushes 10⁹ × 0.01 bits, all of them still in flight. This is the bandwidth-delay product — the pipe's capacity.

Round-trip time

Bandwidth-delay product

The ratio a = T_p / T_t

Utilisation of a send-and-wait sender

Utilisation (efficiency) U = fraction of time the sender is actually busy transmitting. Consider a sender that sends one unit, then waits until a tiny reply comes back before sending the next. One cycle lasts T_t + 2·T_p, of which only T_t is useful:

To keep the link fully busy, the sender would need about 1 + 2a units on the way before the first reply returns. Phase 4 builds a whole family of methods on exactly this idea.

Putting it together

• RTT = 2·T_p; the pipe holds B × T_p bits one way.
• a = T_p/T_t measures how long the link is compared to one unit.
• A send-and-wait sender reaches only U = 1/(1 + 2a); filling the pipe needs about 1 + 2a units in flight.

• RTT is 2·T_p here, not T_p, and not T_t + T_p — read whether the question includes transmission.
• a = T_p / T_t, not T_t / T_p — a big a means a bad send-and-wait link.
• Utilisation formula 1/(1 + 2a) assumes the reply's own transmission time is negligible; if given, add it to the cycle.

"The pipe is long — fill it." U = 1/(1 + 2a): one unit of work for every 2a units of waiting.

We now have every performance tool: T_t, T_p, RTT, BDP, a and U. Next (1.3.4): put them to work comparing circuit switching with packet switching on the same message — when does reserving a path win, and how big should packets be?

1. NAT

   B = 100 Mbps, T_p = 5 ms. Bandwidth-delay product in bits?

   Write your answer before opening the key.

2. NAT

   T_t = 2 ms and T_p = 4 ms. Send-and-wait utilisation (3 decimals)?

   Write your answer before opening the key.

3. MCQ

   For a fixed link, increasing the unit size L (everything else fixed) makes a:

   1. larger
   2. smaller
   3. unchanged
   4. negative
4. NAT

   B = 1 Mbps, T_p = 20 ms. Minimum unit size in bytes for send-and-wait utilisation ≥ 50 %?

   Write your answer before opening the key.

5. MSQ

   Which are true?

   1. RTT for a tiny signal on one link = 2·T_p.
   2. U = 1/(1 + 2a) for send-and-wait.
   3. A large a favours send-and-wait.
   4. B × RTT bits could be sent before the first reply arrives.

• RTT = 2·T_p for tiny signals (add T_t / queuing if stated).
• BDP = B × T_p bits in flight; B × RTT before any reply.
• a = T_p / T_t.
• Send-and-wait: U = T_t/(T_t + 2T_p) = 1/(1 + 2a); throughput = U·B.
• To keep the link busy: about 1 + 2a units in flight.

• RTT (round-trip time) = 2·T_p
• bandwidth-delay product
• a = T_p / T_t
• utilisation (efficiency) U = 1/(1 + 2a)
• send-and-wait sender (one unit per round trip)

1. RTT for a tiny signal?
   Reveal answer

   2·T_p.
2. Bandwidth-delay product?
   Reveal answer

   B × T_p bits in flight.
3. Send-and-wait utilisation?
   Reveal answer

   1/(1 + 2a), a = T_p/T_t.
4. Units in flight to fill the link?
   Reveal answer

   About 1 + 2a.

• U = 1/(1 + 2a); U ≥ 1/2 ⇔ T_t ≥ 2T_p ⇔ L ≥ 2·B·T_p. — one unit sent per round trip, reply transmission time negligible.
• Units needed in flight to fill the link ≈ 1 + 2a. — send-and-wait cycle of T_t + 2T_p; round up for a whole number of units.