Circuit switching আর packet switching — ডেটা কীভাবে যায়

১ · একটি প্রশ্ন: ডেটা যাবে কোন পথে, কীভাবে?

পর্ব ০২-এ দেখেছেন, ইন্টারনেট আসলে অসংখ্য link আর router-এর জাল। ঢাকা থেকে আপনার পাঠানো একটি ছবি চট্টগ্রামের বন্ধুর ফোনে যেতে হয়তো দশ-বারোটি router পার হয়। প্রশ্ন হলো — এই পথটা কে ঠিক করে, আর পথের link-গুলো একসাথে হাজার হাজার মানুষ কীভাবে ব্যবহার করে?

নেটওয়ার্কের ভাষায় এই কাজটির নাম switching — এক link থেকে আসা ডেটাকে ঠিক পরের link-এ পাঠিয়ে দেওয়া। এর দুটি মৌলিক দর্শন আছে। পুরো পর্বটা এই দুইয়ের তুলনা।

২ · Circuit switching — টেলিফোনের পথ

Circuit switching বুঝতে পুরোনো ল্যান্ডফোনের কথা ভাবুন। ১৮৭০-এর দশকে টেলিফোন আবিষ্কারের পর প্রথম দিকের এক্সচেঞ্জে একজন অপারেটর বসতেন একটি বড় বোর্ডের সামনে। আপনি ফোন তুললে তিনি জিজ্ঞেস করতেন কাকে চান, তারপর একটি তার (cord) টেনে আপনার লাইন আর প্রাপকের লাইন জুড়ে দিতেন। কথা শেষ হলে তার খুলে ফেলতেন। পরে স্বয়ংক্রিয় এক্সচেঞ্জ এই কাজ যন্ত্র দিয়ে করতে শুরু করে — ১৮৯০-এর দশকে Almon Strowger-এর স্বয়ংক্রিয় switch এর প্রথম দিকের সফল উদাহরণ হিসেবে পরিচিত।

পুরো বিশ্বের এই টেলিফোন ব্যবস্থাকে বলা হয় PSTN (Public Switched Telephone Network). বাংলাদেশে একসময় T&T-র (এখনকার BTCL) ল্যান্ডফোন এই ধরনের নেটওয়ার্কের ওপর চলত। এর মূল নিয়ম তিনটি ধাপে:

1. Setup (সংযোগ স্থাপন): নম্বর ডায়াল করলে একটি সংকেত-বার্তা (signalling) পথের প্রতিটি switch-এ যায়। প্রতিটি switch পরের link-এ আপনার জন্য একটি অংশ — একটি “চ্যানেল” — সংরক্ষণ করে।
2. Transfer (ডেটা পাঠানো): সংযোগ তৈরি হলে কথা (বা ডেটা) একটি স্থির হারে বয়ে চলে। প্রতিটি switch আগে থেকেই জানে আপনার চ্যানেলের বিট কোন দিকে যাবে — নতুন করে কিছু ভাবতে হয় না।
3. Teardown (সংযোগ ছেড়ে দেওয়া): ফোন রাখলে আরেকটি বার্তা গিয়ে সব switch-কে জানায় যে চ্যানেলগুলো এখন মুক্ত।

নিচের ডায়াগ্রামে একটি ফাইল পাঠানোর circuit দেখুন। পথে দুটি switch (S1, S2), তাই link তিনটি। প্রতিটি link-কে ২৪টি ভাগে (slot) ভাগ করা — এর মানে পরের অংশে বুঝবেন।

1A  -- SETUP(dest=B) --> S12S1 reserves slot 9 on S1-S2, forwards SETUP3S2 reserves slot 2 on S2-B,  B says ACCEPT4CONNECT travels back B -> S2 -> S1 -> A5DATA: 640000 bits at 64 kbps (slot only)6A  -- RELEASE --> all slots freed

Circuit switching-এর সবচেয়ে বড় গুণ হলো নিশ্চয়তা: একবার সংযোগ হলে আপনার হার স্থির, দেরি স্থির, আর ভিড়ের জন্য ডেটা হারানোর ভয় নেই। এজন্যই কণ্ঠস্বরের মতো নিরবচ্ছিন্ন প্রবাহের জন্য এটি প্রায় এক শতাব্দী রাজত্ব করেছে। কিন্তু সবচেয়ে বড় দুর্বলতাও এখানে: নীরবতাও জায়গা দখল করে। ফোনালাপে দুজনের যেকোনো একজন সাধারণত চুপ থাকেন, তবু চ্যানেল পুরোটা সংরক্ষিত।

৩ · FDM আর TDM — একটি তারকে অনেকে ভাগ করা

একটি link-এ অনেকগুলো circuit একসাথে চলে। প্রশ্ন হলো, একটি তারকে টুকরো করা হয় কীভাবে? দুটি প্রধান উপায় — একসাথে নাম multiplexing. (মাধ্যম আর multiplexing-এর পূর্ণ আলোচনা পর্ব ০৮-এ; এখানে শুধু circuit বোঝার জন্য যতটুকু দরকার।)

FDM-এর ছোট অঙ্ক: একটি link-এর ব্যবহারযোগ্য bandwidth ১ MHz, প্রতিটি কণ্ঠ-চ্যানেলে (দুই পাশের সামান্য ফাঁকা guard band-সহ) লাগে ৪ kHz. তাহলে একসাথে চলতে পারে ১,০০০,০০০ ÷ ৪,০০০ = ২৫০টি কথোপকথন।

TDM-এর হিসাব কীভাবে আসে: ডিজিটাল টেলিফোনে কণ্ঠস্বরকে প্রতি সেকেন্ডে ৮,০০০ বার নমুনা নেওয়া হয়, প্রতিটি নমুনা ৮ বিট — অর্থাৎ একটি কণ্ঠ-চ্যানেল = ৮,০০০ × ৮ = ৬৪,০০০ bps = ৬৪ kbps. তাই প্রতি frame-এর দৈর্ঘ্য ১/৮,০০০ সেকেন্ড = ১২৫ μs, আর প্রতিটি slot একবারে ৮ বিট বহন করে। ২৪টি slot থাকলে প্রতি frame-এ ২৪ × ৮ = ১৯২ বিট, প্রতি সেকেন্ডে ১৯২ × ৮,০০০ = ১.৫৩৬ Mbps. উত্তর আমেরিকার T1 লাইনে এর সাথে প্রতি frame-এ ১টি framing বিট যোগ হয়, তাই T1-এর হার ১.৫৪৪ Mbps. বাংলাদেশসহ বেশিরভাগ দেশে প্রচলিত E1-এ ৩২টি slot, হার ২.০৪৮ Mbps.

৪ · Message switching থেকে packet switching

Message switching এসেছে টেলিগ্রাফের যুগ থেকে। কোনো circuit বুকিং নেই — পুরো বার্তাটা (একটি টেলিগ্রাম) প্রথম কেন্দ্রে জমা হয়, সেখানে কর্মী ঠিকানা দেখে পরের কেন্দ্রে পাঠান, সেখানেও পুরোটা জমা হয়, এভাবে গন্তব্যে। পুরোনো ডাকঘরের চিঠি-ব্যবস্থাও এমন: চিঠি প্রথমে স্থানীয় ডাকঘরে, তারপর জেলা সদরের বাছাই কেন্দ্রে, তারপর গন্তব্যের ডাকঘরে। একে বলে message switching.

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

Packet switching-এর মূল কৌশল সরল: একটি বড় বার্তাকে নির্দিষ্ট সর্বোচ্চ আকারের ছোট টুকরোয় ভাঙুন। প্রতিটি টুকরোর সামনে একটি header বসান — যেখানে প্রেরক, প্রাপক আর ক্রমিক নম্বরের মতো তথ্য থাকে, যেমন চিঠির খামে ঠিকানা। তারপর প্রতিটি packet স্বাধীনভাবে ছেড়ে দিন। প্রতিটি router packet পেলে header দেখে ঠিক করে কোন link-এ পাঠাবে (এই সিদ্ধান্তের ভেতরের কাজ — forwarding — পর্ব ১৫-এ)।

Packet switching-এ কোনো setup নেই, কোনো সংরক্ষণ নেই। যে link যখন খালি, তখন যার packet সামনে, সে পাঠায়। একটি link-এ একসাথে বহু ব্যবহারকারীর packet মিশে চলে। দুটি প্রশ্ন তাই উঠে আসে — এতে মোট সময় কত লাগে (অংশ ৫ আর ৬), আর কতজন একসাথে নিরাপদে ভাগ করতে পারে (অংশ ৭)।

৫ · Store-and-forward — প্রতিটি মোড়ে পুরো packet জমা

বেশিরভাগ packet switch আর router store-and-forward নিয়মে চলে: একটি packet-এর সব বিট না আসা পর্যন্ত router সেটিকে পরের link-এ পাঠানো শুরু করে না। কারণ পুরো packet না পেলে সে header-এর সাথে error-check মেলাতে পারে না, আর অনেক নকশায় পুরো packet হাতে না নিয়ে পরের link-এ পাঠানো শুরুও করা যায় না।

একটি link-এ একটি packet: L/R

ধরুন packet-এর আকার L বিট, link-এর হার R bps. প্রেরক প্রথম বিট থেকে শেষ বিট পর্যন্ত link-এ “ঠেলে দিতে” সময় নেয় L/R সেকেন্ড। একে বলে transmission delay. উদাহরণ: ১,০০০ বিটের packet, ১ Mbps link → ১,০০০ ÷ ১০^৬ = ১ ms. (বিট তারের ভেতর দিয়ে অন্য প্রান্তে পৌঁছাতে যে সময় নেয় তা propagation delay, আর router-এর সারিতে অপেক্ষা queuing delay — এগুলোর পূর্ণ হিসাব পর্ব ০৫-এ। এখানে শুধু transmission ধরছি।)

N টি link-এ একটি packet: N·L/R

পথে N টি link (অর্থাৎ মাঝে N − 1 টি router). প্রথম link-এ L/R সময় পরে router-এর হাতে পুরো packet. তারপর সে পরের link-এ পাঠাতে আবার L/R. প্রতিটি link-এ একবার করে, তাই

N টি link-এ P টি packet: (N + P − 1)·L/R — প্রমাণ

এবার একটির বদলে P টি packet, প্রত্যেকটি L বিট, পরপর পাঠানো হচ্ছে। দুটি পর্যবেক্ষণ থেকেই সূত্র আসে:

1. প্রথম packet একা যাচ্ছে, তার সামনে কেউ নেই, তাই সে B-তে পৌঁছায় N·L/R সময়ে।
2. প্রেরক প্রতি L/R সময়ে একটি packet ছাড়ে, আর পথের প্রতিটি link-এর হার সমান — তাই কোনো packet-কে আগেরটির জন্য অপেক্ষা করতে হয় না (packet k যখন কোনো router-এ পৌঁছায়, packet k − 1 ঠিক তখনই সেখান থেকে চলে গেছে)। ফলে packet-গুলো L/R ব্যবধান বজায় রেখে মিছিলের মতো চলে, আর পরের প্রতিটি packet আগেরটির ঠিক L/R পরে B-তে পৌঁছায়।

শেষ (P-তম) packet তাই পৌঁছায় N·L/R + (P − 1)·L/R সময়ে:

আরেকভাবে দেখুন: শেষ packet-টি প্রেরক থেকে বেরোতে পারে P·L/R সময়ে (আগের সবাইকে পাঠাতে হবে), তারপর তাকে বাকি N − 1 টি link পার হতে হয়: P·L/R + (N − 1)·L/R — একই ফল। দুই পথে একই উত্তর আসাটা নিজের হিসাব যাচাইয়ের ভালো উপায়।

এবার সবচেয়ে গুরুত্বপূর্ণ তুলনাটি দেখুন। ৩,০০০ বিটের একটি বার্তা, পথে ৩টি link, প্রতিটি ১ Mbps. একবার পুরো বার্তা হিসেবে (message switching), আরেকবার ১,০০০ বিটের ৩টি packet হিসেবে:

1message M = 3000 bits, L/R = 3 ms per link2t=3 ms : M fully stored at S13t=6 ms : M at S2,  t=9 ms : M at B4packets p1 p2 p3 = 1000 bits, L/R = 1 ms5t=1 ms : p1 at S16t=2 ms : p1 at S2, p2 at S17t=3 ms : p1 at B, p2 at S2, p3 at S18t=4 ms : p2 at B, p3 at S29t=5 ms : p3 at B  -> done

নিচের calculator-এ circuit আর packet দুই পদ্ধতিতেই অংশ ৩-এর সেই ৬,৪০,০০০ বিটের ফাইলটি পাঠানো হয়েছে, আর packet-এর সংখ্যা বদলে দেখা হয়েছে মোট সময় কীভাবে বদলায়। চালিয়ে দেখুন, তারপর F, N বা slots বদলে নিজের অঙ্ক যাচাই করুন:

// Circuit vs packet switching: time to move one file across N links.
// Propagation and queuing are ignored; every link has the same rate R.
const F = 640000;                // file size, bits
const R = 1.536e6;               // link rate, bits/s
const N = 3;                     // links on the path (A - S1 - S2 - B)
const slots = 24, setup = 0.5;   // TDM: 24 users share each link, 0.5 s to set up

const circuitTDM = setup + F / (R / slots);   // our circuit gets one slot = R/24
const circuitFull = setup + F / R;            // imagine the whole link were ours
console.log("circuit, 1 TDM slot (" + R / slots / 1e3 + " kbps): " + circuitTDM.toFixed(3) + " s");
console.log("circuit, full link (" + R / 1e6 + " Mbps): " + circuitFull.toFixed(3) + " s");

const packet = P => (N + P - 1) * (F / P) / R;   // P equal packets, no headers
console.log("packets P | size L (bits) | store-and-forward (s)");
for (const P of [1, 2, 4, 10, 100, 1000]) {
  console.log(String(P).padStart(9) + " | " + String(F / P).padStart(13) +
    " | " + packet(P).toFixed(4).padStart(21));
}

circuit, 1 TDM slot (64 kbps): 10.500 s
circuit, full link (1.536 Mbps): 0.917 s
packets P | size L (bits) | store-and-forward (s)
        1 |        640000 |                1.2500
        2 |        320000 |                0.8333
        4 |        160000 |                0.6250
       10 |         64000 |                0.5000
      100 |          6400 |                0.4250
     1000 |           640 |                0.4175

সূত্রটি “যদি সব link-এর হার সমান হয়” — এই শর্তে প্রমাণিত। Link-এর হার আলাদা হলে প্রতিটি packet-কে প্রতিটি link-এ “আগে থেকে পৌঁছেছে কি না” আর “link খালি কি না” — দুটোই দেখতে হয়। নিচের C প্রোগ্রামটি ঠিক এই নিয়ম ধাপে ধাপে চালায়, তাই অসমান হারেও কাজ করবে (চাইলে পরে নিজে বদলে দেখতে পারেন)। আপাতত উপরের stepper-এর সংখ্যাই নেওয়া হয়েছে:

#include <stdio.h>

/* Store-and-forward: a link may start sending packet i only when
   (a) packet i has fully arrived over the previous link, and
   (b) the link has finished sending packet i-1.                   */
#define P 3                 /* packets          */
#define N 3                 /* links on the path */

int main(void) {
    const long L = 1000, R = 1000000;          /* bits, bits per second */
    const long tx = L * 1000000 / R;           /* L/R in microseconds   */
    long done[P + 1][N + 1] = {{0}};           /* done[i][j]: packet i fully sent on link j */

    printf("L/R = %ld us per packet per link\n", tx);
    for (int i = 1; i <= P; i++) {
        for (int j = 1; j <= N; j++) {
            long ready = done[i][j - 1];       /* arrived from previous link */
            long free_at = done[i - 1][j];     /* link busy until then       */
            long start = ready > free_at ? ready : free_at;
            done[i][j] = start + tx;
            printf("packet %d link %d: %4ld -> %4ld us\n", i, j, start, done[i][j]);
        }
    }
    printf("last bit reaches B at %ld us; (N+P-1)*L/R = %ld us\n",
           done[P][N], (N + P - 1) * tx);
    printf("one %ld-bit message instead: N*(P*L)/R = %ld us\n", P * L, N * P * tx);
    return 0;
}

L/R = 1000 us per packet per link
packet 1 link 1:    0 -> 1000 us
packet 1 link 2: 1000 -> 2000 us
packet 1 link 3: 2000 -> 3000 us
packet 2 link 1: 1000 -> 2000 us
packet 2 link 2: 2000 -> 3000 us
packet 2 link 3: 3000 -> 4000 us
packet 3 link 1: 2000 -> 3000 us
packet 3 link 2: 3000 -> 4000 us
packet 3 link 3: 4000 -> 5000 us
last bit reaches B at 5000 us; (N+P-1)*L/R = 5000 us
one 3000-bit message instead: N*(P*L)/R = 9000 us

৬ · Packet কত বড় হবে — pipelining বনাম header-এর খরচ

অংশ ৫ পড়ে মনে হতে পারে, packet যত ছোট তত ভালো। কিন্তু একটি জিনিস আমরা এতক্ষণ বাদ রেখেছি: প্রতিটি packet-এর সাথে একটি header যায়। IPv4 আর TCP-র সাধারণ header মিলিয়ে প্রায় ৪০ byte (৩২০ বিট) — ডেটা ১ byte হোক বা ১,৪৬০ byte. খামের ওপর ঠিকানা লেখার খরচ চিঠি ছোট হলেও একই।

ধরুন মোট ডেটা F বিট, প্রতিটি packet-এ ডেটা (payload) p বিট আর header h বিট। তাহলে packet-এর সংখ্যা P = F/p, প্রতিটি packet-এর আকার p + h, আর মোট সময়

সর্বোত্তম p বের করা: R দিয়ে গুণ করে বিস্তার করি: T·R = (N − 1)(p + h) + F + F·h/p. p-এর সাপেক্ষে অবকলন করলে (N − 1) − F·h/p² = 0, অর্থাৎ

দ্বিতীয় অবকলন 2F·h/p³ > 0, তাই এটি সত্যিই সর্বনিম্ন বিন্দু। সূত্রের অর্থ সহজ ভাষায়: পথ লম্বা হলে (N বড়) ছোট packet ভালো, কারণ pipelining-এর লাভ বেশি; header বড় হলে বড় packet ভালো, কারণ ছোট packet-এ খরচের ভাগ বেশি। N = 1 হলে (একটিমাত্র link) pipelining-এর কোনো লাভই নেই — তখন একটি বড় packet-ই সেরা।

// Smaller packets pipeline better, but every packet carries a header.
// T = (N + P - 1) * (p + h) / R, where p = payload per packet, P = F / p.
const F = 1e6;      // data to send, bits
const h = 320;      // header per packet, bits (40 bytes)
const N = 5;        // links on the path
const R = 1e6;      // every link: 1 Mbps

console.log("payload p | packets P | total sent (bits) | time T (ms)");
for (const p of [100, 500, 1000, 4000, 8000, 10000, 50000, 1e6]) {
  const P = F / p;
  const T = (N + P - 1) * (p + h) / R;
  console.log(String(p).padStart(9) + " | " + String(P).padStart(9) + " | " +
    String(F + P * h).padStart(17) + " | " + (T * 1e3).toFixed(1).padStart(10));
}
const best = Math.sqrt(F * h / (N - 1));  // from dT/dp = 0
console.log("best payload p* = sqrt(F*h/(N-1)) = " + best.toFixed(0) + " bits");

payload p | packets P | total sent (bits) | time T (ms)
      100 |     10000 |           4200000 |     4201.7
      500 |      2000 |           1640000 |     1643.3
     1000 |      1000 |           1320000 |     1325.3
     4000 |       250 |           1080000 |     1097.3
     8000 |       125 |           1040000 |     1073.3
    10000 |       100 |           1032000 |     1073.3
    50000 |        20 |           1006400 |     1207.7
  1000000 |         1 |           1000320 |     5001.6
best payload p* = sqrt(F*h/(N-1)) = 8944 bits

৭ · Statistical multiplexing — ১০ জন, না ৩৫ জন?

এবার পরীক্ষার সবচেয়ে ক্লাসিক প্রশ্ন। একটি অফিসের ইন্টারনেট link ১ Mbps. প্রত্যেক কর্মী যখন সক্রিয়, তখন তাঁর লাগে ১০০ kbps; কিন্তু মানুষ সারাক্ষণ ডাউনলোড করেন না — পড়েন, ভাবেন, চা খান। ধরুন প্রত্যেকে স্বাধীনভাবে মাত্র ১০% সময় সক্রিয় থাকেন। এমন চলাকে বলে bursty traffic — হঠাৎ অনেক, তারপর দীর্ঘ নীরবতা।

Circuit switching-এ: প্রত্যেককে ১০০ kbps সংরক্ষণ করে দিতে হবে, কারণ কে কখন সক্রিয় হবেন জানা নেই। ১,০০০ ÷ ১০০ = মাত্র ১০ জন. আর গড়ে এই ১০ জনের মাত্র ১ জন সক্রিয় — link-এর ৯০% সময় খালি।

Packet switching-এ: সংরক্ষণ নেই, যে সক্রিয় সে-ই link ব্যবহার করে। ৩৫ জনকে যুক্ত করলে সমস্যা হবে শুধু তখন, যখন একসাথে ১০ জনের বেশি সক্রিয় — তখন চাহিদা ১ Mbps ছাড়িয়ে যায়, packet সারিতে জমে। সেই সম্ভাবনা কত? একে সংখ্যা দিয়ে মাপে binomial distribution.

Binomial হিসাব

N জনের প্রত্যেকে স্বাধীনভাবে p সম্ভাবনায় সক্রিয়। ঠিক k জন সক্রিয় হওয়ার সম্ভাবনা:

C(N, k) হলো N জনের মধ্যে কোন k জন সক্রিয় তা বাছার উপায়ের সংখ্যা; p^k — সেই k জনই সক্রিয়; (1 − p)^N−k — বাকিরা নিষ্ক্রিয়। আমাদের দরকার P(X > ১০) = Σ_k=11..35 P(X = k). হাতে ২৫টি পদ যোগ করা কষ্টকর, তবে পরিপূরক নিয়মে সহজ: P(X > ১০) = ১ − Σ_k=0..10 P(X = k). গড় সক্রিয় সংখ্যা N·p = ৩.৫ — অর্থাৎ ১০ ছাড়ানো গড়ের প্রায় তিন গুণ, তাই সম্ভাবনা খুব ছোট হওয়ারই কথা। নিচের ডায়াগ্রামে কয়েক সেকেন্ডের একটি নমুনা দেখুন, তারপর script দিয়ে আসল সংখ্যা।

1link C = 1000 kbps, each active user 100 kbps2second 1:  3 active  ->  300 kbit3second 2:  5 active  ->  500 kbit4second 3:  2 active  ->  200 kbit5second 4: 12 active  -> 1200 kbit  (over!)6second 5:  4 active  ->  400 kbit + queue75 seconds: 26 user-seconds of demand

// Statistical multiplexing: a 1 Mbps link; each user sends at 100 kbps
// while active, and is active (independently) 10% of the time.
const C = 1e6, r = 100e3, p = 0.1;
const cap = C / r;                        // at most 10 can be active together
function choose(n, k) {                   // n C k without huge factorials
  let c = 1;
  for (let i = 1; i <= k; i++) c = c * (n - k + i) / i;
  return c;
}
function pOver(n) {                       // P(more than cap of n users active)
  let s = 0;
  for (let k = cap + 1; k <= n; k++) s += choose(n, k) * p ** k * (1 - p) ** (n - k);
  return s;
}
console.log("circuit switching: exactly " + cap + " users (" + r / 1e3 + " kbps reserved each)");
console.log("users N | avg active | P(more than " + cap + " active)");
for (const n of [10, 20, 30, 35, 40, 50, 60]) {
  const v = pOver(n);
  console.log(String(n).padStart(7) + " | " + (n * p).toFixed(1).padStart(10) +
    " | " + (v === 0 ? "0" : v.toExponential(2)).padStart(10));
}
let n = cap;
while (pOver(n + 1) < 0.001) n++;        // largest N keeping overload under 0.1%
console.log("largest N with P(overload) < 0.001: " + n);

circuit switching: exactly 10 users (100 kbps reserved each)
users N | avg active | P(more than 10 active)
     10 |        1.0 |          0
     20 |        2.0 |    7.09e-7
     30 |        3.0 |    8.91e-5
     35 |        3.5 |    4.24e-4
     40 |        4.0 |    1.47e-3
     50 |        5.0 |    9.35e-3
     60 |        6.0 |    3.42e-2
largest N with P(overload) < 0.001: 38

৮ · Datagram আর virtual circuit — packet-এর দুই ঘরানা

Packet switching-এর ভেতরেও দুটি ভিন্ন নকশা আছে। পার্থক্য একটি প্রশ্নে: router কি প্রতিটি “সংযোগ” মনে রাখে?

Virtual circuit-এর মূল কৌশল হলো label swapping. প্রতিটি link-এ VC নম্বর আলাদা হতে পারে, কারণ সারা নেটওয়ার্কে একটি অনন্য নম্বর খোঁজা কঠিন; তাই প্রতিটি router packet-এর নম্বর বদলে পরের link-এর নম্বর বসায়। দেখুন:

1A --SETUP(to B)--> R1 --> R2 --> B2R1 adds: in if1 VC 12 -> out if2 VC 223R2 adds: in if1 VC 22 -> out if3 VC 324A sends [VC 12 | data]5R1: lookup (if1, 12) -> send [VC 22 | data] on if26R2: lookup (if1, 22) -> send [VC 32 | data] on if37TEARDOWN: R1, R2 delete their entries

ATM (Asynchronous Transfer Mode) ১৯৯০-এর দশকে টেলিফোন কোম্পানিগুলোর বড় স্বপ্ন ছিল — কণ্ঠ, ভিডিও আর ডেটা সব এক নেটওয়ার্কে, ৫৩ byte-এর স্থির আকারের “cell”-এ (৫ byte header, ৪৮ byte ডেটা), virtual circuit দিয়ে। ইন্টারনেটের IP-র কাছে ATM শেষ পর্যন্ত হেরে যায়, তবে এর ধারণা বেঁচে আছে MPLS-এ। MPLS (স্থাপত্য RFC 3031, ২০০১) ISP-র নেটওয়ার্কের ভেতরে IP packet-এর সামনে একটি ছোট label বসিয়ে virtual circuit-এর মতো পূর্বনির্ধারিত পথে পাঠায় — traffic engineering আর ব্যবসায়িক VPN-এর জন্য। অর্থাৎ বাইরে থেকে ইন্টারনেট datagram, কিন্তু অনেক ISP-র ভেতরে virtual circuit-এর ছায়া রয়ে গেছে।

৯ · সারি, packet loss আর পূর্ণ তুলনা

Packet switching-এর দক্ষতার দাম দুটি: অপেক্ষা আর হারানো. প্রতিটি router-এর প্রতিটি বের হওয়ার link-এর সামনে একটি সারি (output buffer) থাকে। যদি কিছু সময় ধরে packet আসার হার link-এর পাঠানোর হারকে ছাড়ায়, নতুন packet সারিতে দাঁড়ায় — এটাই queuing delay. ঢাকার মোড়ে সবুজ বাতি জ্বললেও যদি চার দিক থেকে একসাথে গাড়ি আসে, লাইন লম্বা হয়। আর buffer সীমিত: সারি পুরো ভরে গেলে নতুন packet ফেলে দেওয়া হয় — একে বলে packet loss. হারানো packet আবার পাঠাবে কি না, তা নির্ভর করে ওপরের স্তরের ওপর (TCP পাঠায় — পর্ব ৩০; UDP নিজে পাঠায় না — পর্ব ২৮)।

সারির দৈর্ঘ্য কীভাবে আসা-যাওয়ার হারের অনুপাতের ওপর নির্ভর করে, delay-এর চার উপাদান (processing, queuing, transmission, propagation) আর throughput-এর পূর্ণ হিসাব আসছে পর্ব ০৫-এ। এখানে শুধু মনে রাখুন: circuit switching-এ দেরি স্থির, packet switching-এ দেরি পরিবর্তনশীল — আর ভিডিও কলে ছবি আটকে যাওয়া বা কণ্ঠ ভেঙে যাওয়ার মূলে এই পরিবর্তনশীলতা।

১০ · AI-এর যুগে switching-এর হিসাব

এই পর্বের অঙ্কগুলো দেখতে সহজ, কিন্তু AI চ্যাটবট এখানে প্রায়ই আত্মবিশ্বাসের সাথে ভুল করে। কারণ সূত্রগুলোর ছোট ছোট শর্ত — header আছে কি না, propagation ধরা হবে কি না, bit না byte — প্রশ্নের ভাষায় লুকানো থাকে, আর মডেল প্রায়ই সবচেয়ে “চেনা” সূত্রটি বসিয়ে দেয়।

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

• প্রতিটি সংখ্যার একক মিলিয়েছি — bit বনাম byte, ১০^৬ বনাম ২^২০
• P = ১ আর N = ১ বসিয়ে সূত্রটি সহজ ক্ষেত্রে ঠিক ফল দেয় কি না দেখেছি
• সংখ্যাগুলো নিজে calculator বা এই পর্বের script-এ আবার হিসাব করেছি
• কোন delay ধরা হয়েছে আর কোনটা বাদ (propagation, queuing, header) — স্পষ্ট লেখা আছে কি না দেখেছি
• উল্লেখ করা RFC, সাল বা প্রযুক্তির নাম নিজে খুঁজে নিশ্চিত হয়েছি