Delay, loss আর throughput — নেটওয়ার্কের গতির হিসাব

১ · নেটওয়ার্ক “ধীর” — আসলে কোন সময়টা?

“নেট আজ খুব স্লো” — এই বাক্যটি আমরা প্রতিদিন বলি। কিন্তু একজন নেটওয়ার্ক প্রকৌশলীর কাছে “স্লো” শব্দটি অস্পষ্ট। ভিডিও কলে কথা দেরিতে পৌঁছাচ্ছে? বড় ফাইল নামতে অনেক সময় লাগছে? গেমে গুলি ছোড়ার পর আধা সেকেন্ড পরে প্রতিক্রিয়া আসছে? তিনটি সমস্যার কারণ আলাদা, সমাধানও আলাদা। এই পর্বে আমরা “গতি” শব্দটিকে কয়েকটি মাপা যায় এমন সংখ্যায় ভাঙব।

পর্ব ০৪-এ দেখেছেন, ইন্টারনেটে ডেটা যায় ছোট ছোট packet-এ ভাগ হয়ে, আর প্রতিটি router পুরো packet হাতে পেয়ে তারপর সামনে পাঠায় — একে বলে store-and-forward. প্রতিটি router-এ packet-টি কিছুক্ষণ আটকে থাকে। কেন আটকে থাকে, আর কতক্ষণ — এটাই এই পর্বের মূল প্রশ্ন।

নেটওয়ার্কের “গতি” নিয়ে কথা বললে আসলে দুই ধরনের প্রশ্ন থাকে, আর দুটি গুলিয়ে ফেলাই সবচেয়ে বড় ভুল:

একটি চওড়া কিন্তু লম্বা হাইওয়ের কথা ভাবুন — অনেক লেন (বেশি throughput), কিন্তু ঢাকা থেকে কক্সবাজার যেতে তবু অনেক ঘণ্টা (বেশি delay). আবার মহল্লার সরু গলি — দূরত্ব কম (কম delay), কিন্তু একবারে একটি রিকশাই যায় (কম throughput). দুটি সংখ্যা স্বাধীন — একটি ভালো হলেই অন্যটি ভালো হয় না।

২ · চার রকম delay — সংজ্ঞা আর সূত্র

একটি router-এ (বা যেকোনো node-এ) একটি packet ঢোকা থেকে পরের router-এ পৌঁছানো পর্যন্ত মোট সময়কে বলে nodal delay:

(ক) Processing delay — d_proc

Processing delay হলো router-এর packet-টি “পড়ে সিদ্ধান্ত নেওয়ার” সময়: header পরীক্ষা, bit-এ ভুল আছে কি না দেখা, forwarding table-এ খুঁজে ঠিক করা কোন output link-এ যাবে (পর্ব ১৫-এ router-এর ভেতর দেখবেন)। আধুনিক hardware router-এ এটি সাধারণত মাইক্রোসেকেন্ড বা তারও কম। সাধারণত অঙ্কে একে খুব ছোট ধরা হয় বা প্রশ্নেই সংখ্যাটি দেওয়া থাকে।

(খ) Queuing delay — d_queue

Queuing delay হলো output link খালি হওয়ার অপেক্ষা। Link-এ যদি আগে থেকে অন্য packet যাচ্ছে বা অপেক্ষায় থাকে, নতুন packet-টিকে লাইনে (buffer-এ) দাঁড়াতে হয়। সামনে কেউ না থাকলে এটি শূন্য; ভিড় থাকলে অনেক বেশি। চারটি delay-এর মধ্যে শুধু এটিই packet থেকে packet-এ বদলায় — তাই একে গড় বা সম্ভাব্যতা দিয়ে মাপতে হয় (অংশ ৪)।

(গ) Transmission delay — d_trans = L/R

Transmission delay হলো packet-এর সব bit link-এ ঠেলে দিতে যে সময় লাগে। Packet-এর দৈর্ঘ্য L bit আর link-এর transmission rate R bit/সেকেন্ড হলে:

এখানে দূরত্বের কোনো ভূমিকা নেই! Link এক মিটার হোক বা এক হাজার কিলোমিটার, ১০ Mbps link-এ ১,৫০০ byte পাঠাতে লাগবে একই সময়। খেয়াল রাখুন, L সাধারণত byte-এ দেওয়া থাকে আর R bit-এ — তাই প্রথমেই ৮ দিয়ে গুণ করা জরুরি।

(ঘ) Propagation delay — d_prop = d/s

Propagation delay হলো একটি bit link-এর এক মাথা থেকে অন্য মাথায় যেতে যে সময় লাগে। দূরত্ব d মিটার আর মাধ্যমে সংকেতের গতি s মিটার/সেকেন্ড হলে:

এখানে packet-এর আকার বা link-এর rate-এর কোনো ভূমিকা নেই। সংকেতের গতি মাধ্যমের ওপর নির্ভর করে: শূন্যে বা বাতাসে আলো/বেতার তরঙ্গ প্রায় ৩ × ১০^৮ m/s; কাচের fiber-এ আলো চলে মোটামুটি দুই-তৃতীয়াংশ গতিতে, প্রায় ২ × ১০^৮ m/s; তামার তারেও কাছাকাছি (তারের ধরনভেদে ০.৬–০.৮ গুণ)। এই পর্বের সব অঙ্কে ধরে নিচ্ছি: তামা আর fiber-এ s = ২ × ১০^৮ m/s, বেতার/উপগ্রহে s = ৩ × ১০^৮ m/s — পরীক্ষার খাতাতেও এই অনুমানটি স্পষ্ট লিখে দেবেন।

প্রথম অঙ্ক — ১,৫০০ byte, ১০০ Mbps, ২,০০০ km

প্রশ্ন: ১,৫০০ byte-এর একটি packet ১০০ Mbps-এর একটি fiber link দিয়ে ২,০০০ km দূরে যাবে। Transmission আর propagation delay কত? কোনটি বড়?

• L = ১,৫০০ × ৮ = ১২,০০০ bit; R = ১০০ × ১০^৬ bit/s
• d_trans = ১২,০০০ / ১০^৮ = ১.২ × ১০^−৪ s = ১২০ µs
• d_prop = (২,০০০ × ১০^৩) / (২ × ১০^৮) = ০.০১ s = ১০ ms
• অনুপাত: ১০ ms ÷ ১২০ µs ≈ ৮৩ গুণ — দূরপাল্লার link-এ propagation-ই প্রধান।

এবার এই সংখ্যাগুলো দিয়েই একটি packet-কে একটি router পার হতে দেখুন। ধরা যাক processing ২০ µs, আর packet-টি পৌঁছে দেখল সামনে আরও ২টি একই আকারের packet অপেক্ষায় আছে।

৩ · Transmission বনাম propagation — পদ্মা সেতুর টোল প্লাজা

এই দুটি delay-এর পার্থক্য বোঝার সবচেয়ে বিখ্যাত উদাহরণ হলো “গাড়ির বহর আর টোল বুথ” (Kurose আর Ross-এর পাঠ্যবইয়ে বহুল ব্যবহৃত)। আমরা একে দেশি রূপ দিই — সংখ্যাগুলো কাল্পনিক, শুধু হিসাবের জন্য।

এবার উল্টো পরিস্থিতিটি ভাবুন, যা প্রথমবার শুনলে অবাক লাগে: ধরুন গাড়ি চলে ঘণ্টায় ১,০০০ km (তাই ১০০ km যেতে ৬ মিনিট), আর বুথে প্রতিটি গাড়ির লাগে ১ মিনিট। প্রথম গাড়ি বুথ ছাড়ে ১ মিনিটে, পরের প্লাজায় পৌঁছায় ১ + ৬ = ৭ মিনিটে। অথচ শেষ গাড়ি প্রথম বুথ ছাড়বে ১০ মিনিটে! অর্থাৎ বহরের প্রথম অংশ গন্তব্যে পৌঁছে গেছে, যখন শেষ অংশ এখনো যাত্রাই শুরু করেনি। Packet-এর ক্ষেত্রেও ঠিক তাই ঘটে যখন d_trans > d_prop — প্রথম bit ওপারে পৌঁছায়, অথচ শেষ bit এখনো প্রেরকের কাছে।

নিচের ডায়াগ্রামে একই packet (১,৫০০ byte = ১২,০০০ bit) একই rate-এর (১০ Mbps) দুটি link-এ পাঠানো হচ্ছে — একটি ২০০ m-এর অফিসের তামার তার, অন্যটি ২,০০০ km-এর fiber. দুই link-এই d_trans = ১২,০০০ ÷ ১০^৭ = ১.২ ms.

দ্বিতীয় অঙ্ক — ঢাকা থেকে সিঙ্গাপুর (কাল্পনিক হিসাব)

বাংলাদেশের আন্তর্জাতিক ইন্টারনেটের বড় অংশ সমুদ্রের নিচের fiber কেবল (submarine cable) দিয়ে যায় — যেমন SEA-ME-WE সিরিজের কেবল, যার landing station কক্সবাজার আর কুয়াকাটায়। কেবল সোজা পথে যায় না; উপকূল আর সাগর ঘুরে যায়, তাই ভৌগোলিক দূরত্বের চেয়ে কেবলের দৈর্ঘ্য বেশি। আসল দৈর্ঘ্য কেবলভেদে আলাদা — আমরা শুধু হিসাবের জন্য ধরে নিই ঢাকা থেকে সিঙ্গাপুরের কোনো ডেটা সেন্টার পর্যন্ত মোট fiber পথ ৪,০০০ km.

• একমুখী propagation = ৪ × ১০^৬ ÷ ২ × ১০^৮ = ২০ ms
• যাওয়া-আসা (propagation-এর অংশ) = ৪০ ms — এটি পদার্থবিজ্ঞানের নিচের সীমা; router-এর processing, queuing আর পথের বাঁক মিলিয়ে বাস্তব ping এর চেয়ে বেশি আসে।
• ১০ Gbps link-এ ১,৫০০ byte-এর transmission মাত্র ১.২ µs — ২০ ms-এর পাশে নগণ্য।

এজন্যই বড় প্রতিষ্ঠানগুলো জনপ্রিয় কনটেন্ট দেশের ভেতরে বা কাছাকাছি cache রাখে (পর্ব ৩৮-এ CDN), আর দেশের ভেতরের ISP-দের মধ্যে ট্রাফিক বিদেশ না ঘুরিয়ে স্থানীয় exchange-এ (যেমন BDIX) আদান-প্রদানের চেষ্টা থাকে (পর্ব ২৫)। দূরত্ব কমানোই latency কমানোর সবচেয়ে কার্যকর উপায়।

৪ · Queuing delay আর traffic intensity — রাস্তা ভরে গেলে

ঢাকার কোনো মোড়ে ট্রাফিক পুলিশ মিনিটে ৩০টি গাড়ি পার করাতে পারেন। মিনিটে ১৫টি গাড়ি এলে প্রায় কেউ দাঁড়ায় না। ২৭টি এলে মাঝে মাঝে ছোট লাইন হয়। ৩০টি বা তার বেশি এলে? লাইন শুধু লম্বাই হতে থাকে — অফিস টাইমের জ্যাম। Router-এর queue ঠিক এভাবেই আচরণ করে।

ধরা যাক প্রতিটি packet-এর দৈর্ঘ্য L bit, প্রতি সেকেন্ডে গড়ে a-টি packet আসে, আর output link-এর rate R bit/s. তাহলে প্রতি সেকেন্ডে গড়ে La bit আসছে, আর বের করা যায় R bit. এদের অনুপাতকে বলে traffic intensity:

• ρ > ১: যত bit আসছে, বের করা যায় তার চেয়ে কম। Queue সীমাহীনভাবে বাড়তে চাইবে, delay অসীমের দিকে — বাস্তবে buffer ভরে packet ফেলা শুরু হয়। নকশার প্রথম নিয়ম: ρ কখনো ১-এর বেশি হতে দেওয়া যাবে না।
• ρ ≤ ১: গড়ে চাপ সামলানো যায়, কিন্তু queue কতটা লম্বা হবে তা নির্ভর করে packet-গুলো কীভাবে আসে তার ওপর। সমান ফাঁকে এলে (প্রতি L/R সময়ে ঠিক একটি) কাউকে অপেক্ষা করতে হয় না। একসাথে দলবেঁধে (burst) এলে শেষের দিকের packet-কে অপেক্ষা করতে হয়।
• ρ ১-এর কাছাকাছি: এলোমেলোভাবে (random) আসা packet-এর ক্ষেত্রে গড় queuing delay অনুপাতহীনভাবে লাফিয়ে বাড়ে। ρ সামান্য বাড়লেই delay অনেক বাড়ে।

উদাহরণ: ১০০ Mbps link, ১,৫০০ byte-এর packet, প্রতি সেকেন্ডে ৮,০০০টি আসে। ρ = ১২,০০০ × ৮,০০০ ÷ ১০^৮ = ০.৯৬ — link ৯৬% ব্যস্ত, এখানে বড় queue হওয়ার আশঙ্কা প্রবল।

এই বক্ররেখার আকার কোথা থেকে আসে? Queuing theory-র একটি সরল মডেলে (packet এলোমেলো Poisson ধারায় আসে, সবার আকার সমান — একে বলে M/D/1 queue) গড় অপেক্ষা হয় W = ρ/(2(1−ρ)) × L/R. Packet-এর আকারও এলোমেলো হলে (M/M/1) W = ρ/(1−ρ) × L/R. দুই সূত্রেই হর-এ আছে (১ − ρ) — ρ যত ১-এর কাছে যায়, হর তত শূন্যের কাছে, আর ফল তত বিশাল। নিচের simulator একটি router queue চালিয়ে এই তত্ত্ব যাচাই করে: সব packet একই আকারের, আগমন এলোমেলো কিন্তু নির্দিষ্ট seed থেকে তৈরি, তাই প্রতিবার একই ফল।

// One router queue, fixed-size packets: service time S = L/R = 1 unit.
// Random (Poisson) arrivals from a seeded generator -> the same output every run.
function rng(seed) {                         // mulberry32: small, deterministic
  return () => {
    seed = (seed + 0x6D2B79F5) | 0;
    let t = Math.imul(seed ^ (seed >>> 15), 1 | seed);
    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}
const N = 400000, BUF = 20;                  // packets per run, buffer size (packets)
const S_us = 120;                            // 1500 B at 100 Mbps = 120 us per packet
console.log("La/R  avg wait(x L/R)  M/D/1 theory  avg wait(us)  loss(buffer=20)");
for (const rho of [0.5, 0.9, 0.99]) {
  const rand = rng(2026);
  let work = 0, sum = 0;                     // unlimited buffer: work left at arrival
  let workB = 0, lost = 0;                   // finite buffer of BUF packets
  for (let i = 0; i < N; i++) {
    const gap = -Math.log(1 - rand()) / rho; // exponential gap, mean 1/rho
    work = Math.max(0, work - gap);
    sum += work;                             // this packet waits 'work' units
    work += 1;
    workB = Math.max(0, workB - gap);
    if (workB > BUF) lost++; else workB += 1; // more than BUF ahead -> drop
  }
  const w = sum / N, theory = rho / (2 * (1 - rho));
  console.log(rho.toFixed(2).padEnd(6) + w.toFixed(2).padStart(10) +
    theory.toFixed(2).padStart(15) + (w * S_us).toFixed(0).padStart(14) +
    ((100 * lost / N).toFixed(3) + "%").padStart(14));
}

La/R  avg wait(x L/R)  M/D/1 theory  avg wait(us)  loss(buffer=20)
0.50        0.50           0.50            60        0.000%
0.90        4.53           4.50           544        0.154%
0.99       51.39          49.50          6167        1.982%

Packet loss — buffer ভরে গেলে

বাস্তবের router-এর buffer অসীম নয়। Queue ভরা অবস্থায় নতুন packet এলে router সেটিকে ফেলে দেয় (সবচেয়ে সরল নীতি “drop-tail” — লাইনের শেষে জায়গা না থাকলে বাদ)। প্রেরকের কাছে এটি packet loss. তখন কী হবে, তা নির্ভর করে ওপরের স্তরের protocol-এর ওপর: TCP হারানো packet আবার পাঠায় (পর্ব ৩০) আর পাঠানোর গতি কমিয়ে দেয় (পর্ব ৩২); UDP-তে চলা ভিডিও কলে সেই মুহূর্তের ছবি বা শব্দ হারিয়ে যায়। Packet loss তাই নেটওয়ার্কের পারফরম্যান্সের তৃতীয় মাপকাঠি — delay আর throughput-এর পাশে।

৫ · End-to-end delay, RTT আর ping

এক router-এর হিসাব জানা হলো। কিন্তু আপনার packet ঢাকা থেকে সিঙ্গাপুর যেতে সাধারণত ১০–২০টি router পার হয়। ধরা যাক উৎস আর গন্তব্যের মাঝে N − ১টি router, অর্থাৎ মোট N-টি link; নেটওয়ার্ক ফাঁকা (queuing নেই), আর সব link একই রকম। তাহলে end-to-end delay:

Link-গুলো ভিন্ন হলে প্রতিটির নিজের d_trans আর d_prop আলাদা করে যোগ করতে হয়। উদাহরণ: ৩টি link (মাঝে ২টি router), প্রতিটি ১০ Mbps আর ১,০০০ km, processing ০.১ ms, packet ১,৫০০ byte. প্রতি link-এ d_trans = ১.২ ms, d_prop = ৫ ms, তাই d_end-end = ৩ × (০.১ + ১.২ + ৫) = ১৮.৯ ms.

পর্ব ০৪-এর store-and-forward সূত্রের সাথে মিলিয়ে নিন: P-টি packet পরপর পাঠালে (propagation আর processing বাদ দিয়ে) শেষ packet পৌঁছায় (N + P − ১) × L/R সময়ে। উপরের ৩টি link-এ ৪টি packet: (৩ + ৪ − ১) × ১.২ = ৭.২ ms. কারণ প্রথম packet-এর পাইপলাইন ভরে গেলে প্রতি L/R সময়ে একটি করে packet বেরোয় — packet switching-এর এই “পাইপলাইন”-ই বড় বার্তাকে টুকরো করার সুবিধা।

RTT — যাওয়া আর ফিরে আসা

অনেক কাজে একমুখী delay-এর চেয়ে গুরুত্বপূর্ণ হলো RTT (round-trip time): একটি ছোট বার্তা পাঠিয়ে উত্তর ফিরে আসা পর্যন্ত সময়। ওয়েবপেজ খোলার সময় প্রতিটি প্রশ্ন-উত্তর (DNS, TCP handshake, TLS, HTTP request) কমপক্ষে একটি RTT খায়। পথ দুই দিকে একই হলে RTT ≈ ২ × একমুখী delay, কিন্তু ইন্টারনেটে যাওয়া আর আসার পথ আলাদা হতেই পারে, আর queue দুই দিকে আলাদা — তাই RTT মাপাই নির্ভরযোগ্য, অনুমান নয়।

RTT মাপার সবচেয়ে পরিচিত টুল ping. এটি গন্তব্যে একটি ICMP Echo Request পাঠায়, গন্তব্য ICMP Echo Reply ফেরত দেয়, আর ping দুই মুহূর্তের পার্থক্য দেখায় (ICMP-এর বিস্তারিত পর্ব ২০-এ)। নিজের কম্পিউটারের loopback ঠিকানায় (127.0.0.1) ping করলে packet কোনো তারেই নামে না — kernel-এর ভেতরেই ঘুরে আসে। ফলে সেখানে কোনো propagation বা link-এর transmission নেই; যা থাকে তা কেবল সফটওয়্যারের processing.

# Round-trip time to our own machine (loopback). No outside network needed.
if command -v ping >/dev/null; then
  ping -c 3 127.0.0.1 2>&1 || echo "ping exists but could not run here (needs raw/ICMP socket permission)"
else
  echo "ping: not installed in this container"
fi
echo "--- loopback interface, from /sys and /proc ---"
echo "lo state: $(cat /sys/class/net/lo/operstate 2>/dev/null || echo unknown), mtu: $(cat /sys/class/net/lo/mtu 2>/dev/null || echo ?)"
awk '/lo:/ {sub(/.*lo:/, ""); print "lo received " $1 " bytes, " $2 " packets; sent " $9 " bytes, " $10 " packets"}' /proc/net/dev

ping: not installed in this container
--- loopback interface, from /sys and /proc ---
lo state: unknown, mtu: 65536
lo received 0 bytes, 0 packets; sent 0 bytes, 0 packets

একটি সাধারণ Linux কম্পিউটারে (যেখানে ping চালানোর অনুমতি আছে) একই কমান্ডের আউটপুট দেখতে এমন — উদাহরণ, আপনার সংখ্যা আলাদা হবে:

$ ping -c 3 127.0.0.1
PING 127.0.0.1 (127.0.0.1) 56(84) bytes of data.
64 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.045 ms
64 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.060 ms
64 bytes from 127.0.0.1: icmp_seq=3 ttl=64 time=0.057 ms

--- 127.0.0.1 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2043ms
rtt min/avg/max/mdev = 0.045/0.054/0.060/0.006 ms

শেষ লাইনটি পড়তে শিখুন: সর্বনিম্ন, গড়, সর্বোচ্চ RTT আর mdev (RTT কতটা ছড়ানো — jitter-এর একটি মোটামুটি মাপ)। time 2043ms মানে পুরো পরীক্ষায় লেগেছে প্রায় ২ সেকেন্ড, কারণ ping প্রতি সেকেন্ডে একটি করে পাঠায় — এটি RTT নয়। Windows-এ কমান্ডটি ping -n 3 127.0.0.1 (Linux/macOS-এ -c, Windows-এ -n), আর loopback-এ সাধারণত time<1ms দেখায়। Linux-এ সাধারণ ব্যবহারকারী ping চালাতে পারেন বিশেষ অনুমতি (capability) বা kernel-এর “ping socket” সেটিং-এর কারণে; container-এ এগুলো প্রায়ই বন্ধ থাকে।

ping না চললেও loopback-এর RTT নিজেই মাপা যায়। নিচের C প্রোগ্রামে দুটি UDP socket 127.0.0.1-এ বসানো: A থেকে B-তে ৬৪ byte-এর একটি datagram, B সেটি ফেরত পাঠায় A-তে — এক হাজার বার, প্রতিবার ঘড়ি ধরে (socket প্রোগ্রামিং বিস্তারিত পর্ব ৪২-এ)।

#include <stdio.h>
#include <time.h>
#include <arpa/inet.h>
#include <sys/socket.h>

static double now_us(void) {
    struct timespec t;
    clock_gettime(CLOCK_MONOTONIC, &t);
    return t.tv_sec * 1e6 + t.tv_nsec / 1e3;
}
int main(void) {
    struct sockaddr_in a = {0}, b = {0};
    socklen_t len = sizeof b;
    int A = socket(AF_INET, SOCK_DGRAM, 0), B = socket(AF_INET, SOCK_DGRAM, 0);
    a.sin_family = b.sin_family = AF_INET;
    a.sin_addr.s_addr = b.sin_addr.s_addr = htonl(INADDR_LOOPBACK);  /* 127.0.0.1 */
    bind(A, (struct sockaddr *)&a, sizeof a);   /* port 0 = kernel picks one */
    bind(B, (struct sockaddr *)&b, sizeof b);
    getsockname(A, (struct sockaddr *)&a, &len);
    getsockname(B, (struct sockaddr *)&b, &len);
    char msg[64] = "ping", buf[64];
    const int N = 1000;  double min = 1e9, max = 0, sum = 0;
    for (int i = 0; i < N; i++) {
        double t0 = now_us();
        sendto(A, msg, sizeof msg, 0, (struct sockaddr *)&b, sizeof b);  /* A -> B */
        recv(B, buf, sizeof buf, 0);
        sendto(B, buf, sizeof buf, 0, (struct sockaddr *)&a, sizeof a);  /* B -> A */
        recv(A, buf, sizeof buf, 0);
        double rtt = now_us() - t0;
        sum += rtt; if (rtt < min) min = rtt; if (rtt > max) max = rtt;
    }
    printf("%d UDP round trips on 127.0.0.1, 64-byte datagram\n", N);
    printf("min %.1f us, avg %.1f us, max %.1f us\n", min, sum / N, max);
    return 0;
}

1000 UDP round trips on 127.0.0.1, 64-byte datagram
min 11.4 us, avg 14.9 us, max 162.8 us

৬ · Throughput আর bottleneck link

Delay বলে “কত দেরিতে”, throughput বলে “কত পরিমাণে”। সার্ভার থেকে আপনার কম্পিউটারে একটি ফাইল আসছে — কোনো এক মুহূর্তে যে হারে bit পৌঁছাচ্ছে, তা instantaneous throughput (ডাউনলোড ম্যানেজারে যে লাফানো সংখ্যাটি দেখেন)। F bit-এর পুরো ফাইল নামতে T সেকেন্ড লাগলে average throughput = F/T. ৬০ MB-এর একটি ভিডিও ২০ সেকেন্ডে নামলে গড় throughput = ৬০ × ৮ ÷ ২০ = ২৪ Mbps.

পথে যদি অনেকগুলো link থাকে, throughput ঠিক করে সবচেয়ে ধীর link-টি — একে বলে bottleneck link. পানির পাইপের কথা ভাবুন: মোটা পাইপের মাঝখানে এক টুকরো সরু পাইপ থাকলে পুরো লাইনের প্রবাহ সেই সরু অংশের সমান। সার্ভারের link Rs আর আপনার link Rc হলে throughput = min(Rs, Rc).

কিন্তু মাঝখানের ইন্টারনেট “core”-ও তো অন্যদের সাথে ভাগ করা। ধরা যাক মাঝের একটি link-এর rate R, আর সেখান দিয়ে একসাথে n-টি ডাউনলোড চলছে, প্রত্যেকে মোটামুটি সমান ভাগ পায়। তাহলে আপনার ভাগ R/n, আর:

উদাহরণ: Rs = ২ Mbps, Rc = ১ Mbps, মাঝের link R = ৫ Mbps যা ১০টি ডাউনলোড ভাগ করছে। min(২, ১, ০.৫) = ০.৫ Mbps — এখানে আপনার বাড়ির link নয়, ভাগ করা core-ই bottleneck. সাধারণত ইন্টারনেটের core link-গুলো খুব মোটা, তাই bottleneck বেশিরভাগ সময় শেষ প্রান্তে (access network) থাকে — কিন্তু সবসময় নয়, যেমন সন্ধ্যার ভিড়ে কোনো ISP-র আন্তর্জাতিক link ভরে গেলে।

৭ · Bandwidth, throughput, latency, jitter — চারটি আলাদা জিনিস

দৈনন্দিন কথায় এই শব্দগুলো গুলিয়ে যায়, কিন্তু চাকরির পরীক্ষা আর ইন্টারভিউতে পার্থক্যটিই জানতে চাওয়া হয়। মোবাইল ডেটার উদাহরণ দিয়ে দেখি (সংখ্যাগুলো উদাহরণমাত্র — অপারেটর, এলাকা আর সময়ভেদে অনেক বদলায়):

কোন কাজে কোনটি গুরুত্বপূর্ণ? বড় ফাইল নামাতে throughput; অনলাইন গেম আর শেয়ার বাজারের অর্ডারে latency; ভিডিও/ভয়েস কলে latency আর jitter দুটোই। Jitter-এর মূল কারণ queuing delay-এর ওঠানামা (অংশ ৪) — আর মোবাইলে বেতার চ্যানেলের অবস্থা বদলানো, handover (পর্ব ৫১)। ভিডিও কলের অ্যাপ প্রাপকের দিকে একটি ছোট “jitter buffer” রাখে: packet কিছুক্ষণ জমিয়ে সমান তালে বাজায়। ফলে কাটা-কাটা ভাব কমে, কিন্তু latency সামান্য বাড়ে — আবারও একটি trade-off.

৮ · Bandwidth-delay product আর এককের ফাঁদ

অংশ ৩-এর stepper-এ দেখেছেন, লম্বা link-এ একসাথে ১,০০,০০০ bit “পথে ভাসছে”। এই সংখ্যাটির নাম আছে: bandwidth-delay product (BDP).

যুক্তি (খাতায় যেভাবে লিখবেন): প্রেরক প্রতি সেকেন্ডে R bit তারে নামায়। একটি bit তারে নামার মুহূর্ত থেকে ওপারে পৌঁছাতে d_prop সময় লাগে, তাই কোনো এক মুহূর্তে তারের ওপর থাকে ঠিক সেই bit-গুলো, যেগুলো শেষ d_prop সময়ে পাঠানো হয়েছে — অর্থাৎ R × d_prop bit. এখন ধরুন প্রেরক নিশ্চিত হতে চায় প্রতিটি bit পৌঁছেছে (প্রাপক “পেয়েছি” বার্তা, অর্থাৎ ACK, ফেরত পাঠায়)। প্রথম bit পাঠানো থেকে তার ACK ফিরে আসা পর্যন্ত লাগে এক RTT. এই সময় জুড়ে link পুরো গতিতে ব্যস্ত রাখতে হলে প্রেরককে ACK ছাড়াই R × RTT bit পাঠিয়ে রাখার অনুমতি থাকতে হবে। কম অনুমতি (W bit) থাকলে প্রতি RTT-তে সর্বোচ্চ W bit যায়, তাই:

উদাহরণ: ১০০ Mbps link, RTT ৪০ ms (ঢাকা–সিঙ্গাপুরের কাল্পনিক হিসাবের মতো)। BDP = ১০^৮ × ০.০৪ = ৪ × ১০^৬ bit = ৫,০০,০০০ byte (৫০০ KB). প্রেরক যদি ACK ছাড়া সর্বোচ্চ ৬৪ KB (৬৫,৫৩৫ byte) পাঠাতে পারে, throughput ≤ ৬৫,৫৩৫ × ৮ ÷ ০.০৪ ≈ ১৩.১ Mbps — ১০০ Mbps-এর link থাকা সত্ত্বেও! এই “ACK ছাড়া কতটা পাঠানো যায়” সীমাটিই TCP-র window. পর্ব ২৯–৩১-এ TCP-র সংযোগ, নির্ভরযোগ্যতা আর sliding window-এ ঠিক এই হিসাব ফিরে আসবে, আর পর্ব ৫৬-এ বাস্তব tuning.

নিচের calculator চারটি delay, RTT আর BDP একসাথে হিসাব করে — তিনটি পরিস্থিতিতে: অফিসের LAN, দেশ বা মহাদেশজুড়ে fiber, আর geostationary উপগ্রহ। Geostationary উপগ্রহ বিষুবরেখার প্রায় ৩৫,৭৮৬ km ওপরে থাকে; একমুখী যাত্রা মানে মাটি → উপগ্রহ → মাটি, অর্থাৎ অন্তত ২ × ৩৫,৭৮৬ km (ব্যবহারকারী ঠিক নিচে থাকলে; অন্য জায়গায় পথ আরও লম্বা)।

// One packet, one link: the four delays, RTT and the bandwidth-delay product.
// Assumption: the reply has the same size and sees the same delays (RTT = 2 x one-way).
function fmt(sec) {                          // seconds -> readable unit
  if (sec >= 1) return sec.toFixed(3) + " s";
  if (sec >= 1e-3) return (sec * 1e3).toFixed(3) + " ms";
  return (sec * 1e6).toFixed(3) + " us";
}
function bytes(b) { return b >= 1e6 ? (b / 1e6).toFixed(2) + " MB" : (b / 1e3).toFixed(2) + " KB"; }
function link(name, L_bytes, R_bps, d_m, s_mps, proc_s, queue_s) {
  const L = L_bytes * 8;                     // packet length in bits
  const trans = L / R_bps;                   // L / R
  const prop = d_m / s_mps;                  // d / s
  const total = proc_s + queue_s + trans + prop;
  const rtt = 2 * total;
  console.log(`== ${name}: L=${L_bytes} B, R=${R_bps / 1e6} Mbps, d=${d_m / 1e3} km`);
  console.log(`  processing   ${fmt(proc_s)}`);
  console.log(`  queuing      ${fmt(queue_s)}`);
  console.log(`  transmission ${fmt(trans)}   (L/R)`);
  console.log(`  propagation  ${fmt(prop)}   (d/s)`);
  console.log(`  one-way      ${fmt(total)}   RTT ~ ${fmt(rtt)}`);
  console.log(`  bits on the wire (R x prop) = ${(R_bps * prop).toFixed(0)}`);
  console.log(`  BDP (R x RTT) = ${(R_bps * rtt).toExponential(3)} bits = ${bytes(R_bps * rtt / 8)}`);
}
link("LAN, copper", 1500, 1e9, 100, 2e8, 5e-6, 0);
link("Cross-country fiber", 1500, 10e9, 4000e3, 2e8, 5e-6, 100e-6);
// Geostationary: ground -> satellite -> ground = 2 x 35,786 km, radio at ~3e8 m/s
link("GEO satellite", 1500, 50e6, 2 * 35786e3, 3e8, 5e-6, 1e-3);

== LAN, copper: L=1500 B, R=1000 Mbps, d=0.1 km
  processing   5.000 us
  queuing      0.000 us
  transmission 12.000 us   (L/R)
  propagation  0.500 us   (d/s)
  one-way      17.500 us   RTT ~ 35.000 us
  bits on the wire (R x prop) = 500
  BDP (R x RTT) = 3.500e+4 bits = 4.38 KB
== Cross-country fiber: L=1500 B, R=10000 Mbps, d=4000 km
  processing   5.000 us
  queuing      100.000 us
  transmission 1.200 us   (L/R)
  propagation  20.000 ms   (d/s)
  one-way      20.106 ms   RTT ~ 40.212 ms
  bits on the wire (R x prop) = 200000000
  BDP (R x RTT) = 4.021e+8 bits = 50.27 MB
== GEO satellite: L=1500 B, R=50 Mbps, d=71572 km
  processing   5.000 us
  queuing      1.000 ms
  transmission 240.000 us   (L/R)
  propagation  238.573 ms   (d/s)
  one-way      239.818 ms   RTT ~ 479.637 ms
  bits on the wire (R x prop) = 11928667
  BDP (R x RTT) = 2.398e+7 bits = 3.00 MB

এককের ফাঁদ — Mbps বনাম MB/s, ১০^৬ বনাম ২^২০

নেটওয়ার্কের সবচেয়ে বেশি ভুল হয় অঙ্কে নয়, এককে। তিনটি নিয়ম মুখস্থ রাখুন:

1. ছোট b = bit, বড় B = byte. ১ byte = ৮ bit. ISP-র প্ল্যান আর link-এর rate bit-এ (Mbps); ব্রাউজার আর ডাউনলোড ম্যানেজারের গতি সাধারণত byte-এ (MB/s). ১০০ Mbps ÷ ৮ = ১২.৫ MB/s.
2. Rate-এ সবসময় দশমিক: ১ Mbps = ১০^৬ bit/s, ১ Gbps = ১০^৯ bit/s — কখনো ২^২০ নয়।
3. ফাইল আর মেমরির আকারে দুই রীতি: MB = ১০^৬ byte (দশমিক, SI), আর MiB = ২^২০ = ১০,৪৮,৫৭৬ byte (binary, IEC). Windows-এর File Explorer binary হিসাব করে কিন্তু লেখে “MB”; হার্ডডিস্ক বিক্রেতা আর macOS দশমিক হিসাব করে। প্রশ্নে কোনটি, স্পষ্ট না থাকলে নিজের অনুমান লিখে দিন।

৯ · AI-এর যুগে delay আর throughput-এর অঙ্ক

“১৫০০ byte, ১০ Mbps, ৫০০০ km — total delay কত?” AI-কে জিজ্ঞেস করলে মুহূর্তে উত্তর পাবেন, সুন্দর ধাপসহ। কিন্তু নেটওয়ার্কের অঙ্কে AI-এর ভুলগুলো খুব চেনা ধরনের — আর ভুলটা প্রায়ই এককে, যা আত্মবিশ্বাসী ভাষার নিচে চাপা পড়ে।

AI-এর উত্তর মানার আগে — চেকলিস্ট

• প্রতিটি সংখ্যার একক মিলিয়েছি: L bit-এ, R bit/s-এ, d মিটারে, s m/s-এ
• Rate-এ ১০^৬/১০^৯ আর ফাইলের আকারে MB বনাম MiB — কোনটি ব্যবহার হয়েছে, দেখেছি
• উপরের calculator-এ বা হাতে ক্যালকুলেটরে অন্তত একটি সংখ্যা নিজে আবার হিসাব করেছি
• উত্তরটি বাস্তবের সাথে মানানসই কি না ভেবেছি — যেমন LAN-এ propagation কয়েক µs, উপগ্রহে কয়েকশো ms
• কমান্ড আর RFC নম্বর man page বা rfc-editor.org-এ যাচাই করেছি, আর নিজের ল্যাব/VM ছাড়া অন্যের নেটওয়ার্কে পরীক্ষা চালাইনি