I/O আর bus — memory-mapped I/O, port I/O, PCIe আর USB

১ · I/O-র সমস্যা — যন্ত্র ভিন্ন, গতি ভিন্ন, আর আসে অসময়ে

এ পর্যন্ত আমরা CPU আর মেমরির ভেতরে ছিলাম। কিন্তু কাজ শুরু হয় বাইরে থেকে — কীবোর্ডের চাপ, network-এর packet — আর শেষ হয় বাইরে: পর্দা, স্পিকার, SSD. CPU আর মেমরির বাইরের এই যোগাযোগই I/O (input/output). মডিউল ৯-এর এই প্রথম পর্বে দেখব, CPU কীভাবে যন্ত্রের সাথে কথা বলে, আর তাদের যুক্ত করার পথ — bus আর serial link — কীভাবে কাজ করে।

I/O কেন আলাদা মনোযোগ চায়? তিনটি কারণ:

• যন্ত্রগুলো খুবই ভিন্ন। কীবোর্ড, mouse, প্রিন্টার, network card, GPU, SSD, তাপমাত্রার sensor — প্রত্যেকের নিজস্ব নিয়ম। CPU-র ISA প্রতিটি যন্ত্রের জন্য আলাদা instruction রাখতে পারে না; দরকার একটি সাধারণ পদ্ধতি।
• গতির পার্থক্য বিশাল। একজন মানুষ সেকেন্ডে বড়জোর ১০টির মতো key চাপেন — কয়েক byte/s. একটি আধুনিক NVMe SSD কয়েক GB/s দিতে পারে। মাঝখানে প্রায় ১০^৯ গুণের ফারাক। কিছু যন্ত্র CPU-র তুলনায় ভীষণ ধীর, কিছু এত দ্রুত যে CPU-ই হয়ে যায় বাধা।
• ঘটনা আসে অসময়ে (asynchronous). কখন key চাপা হবে বা packet আসবে, প্রোগ্রাম জানে না। CPU-র clock আর যন্ত্রের clock আলাদা; যন্ত্রের নিজের সময়ে কাজ শেষ হয়।

তিনটি প্রশ্ন: (১) CPU একটি যন্ত্রের register-কে কোন ঠিকানায় চেনে? (২) যন্ত্র কখন তৈরি, CPU কীভাবে জানে — এখানে polling, পরের পর্বে interrupt ও DMA. (৩) ডেটা তারে কীভাবে যায় — bus, PCIe, USB. Driver আর buffering-এর software দিক OS কোর্সের I/O সিস্টেম পর্বে আছে।

২ · Device controller আর device register — status, control, data

প্রতিটি যন্ত্রের সাথে CPU সরাসরি কথা বলে না; বলে তার device controller-এর সাথে। Controller হলো যন্ত্রের পাশে বা chip-এর ভেতরে বসানো একটি ছোট digital circuit — কখনো সাধারণ FSM (পর্ব ১৭), কখনো নিজস্ব firmware চালানো ছোট একটি processor. সে যন্ত্রের ভেতরের জটিলতা (motor ঘোরানো, flash-এর block মোছা, ethernet-এর signal) সামলায়, আর CPU-র দিকে কয়েকটি সরল device register দেখায়। সাধারণত তিন ধরনের:

একটি গুরুত্বপূর্ণ পার্থক্য মনে রাখুন: device register মেমরির মতো আচরণ করে না. RAM-এর একটি ঘরে ৫ লিখলে পরে পড়লে ৫-ই পাবেন। কিন্তু device register-এ:

• পড়া মান নিজে থেকে বদলায় — যন্ত্র কাজ শেষ করলে status বিট বসে যায়, CPU কিছু না লিখলেও।
• পড়ারও পার্শ্বপ্রতিক্রিয়া থাকতে পারে — UART-এর receive register পড়লেই FIFO থেকে byte সরে যায়; দুবার পড়লে দ্বিতীয় byte পাবেন।
• একই ঠিকানায় পড়া আর লেখা দুটি ভিন্ন register হতে পারে (অংশ ৪-এ দেখবেন)।
• লেখার ক্রম গুরুত্বপূর্ণ — “আগে ঠিকানা, তারপর start বিট” — এই ক্রম উল্টে গেলে যন্ত্র ভুল কাজ শুরু করবে।

এই চারটি বৈশিষ্ট্যই পরের অংশে ঠিক করে দেবে, cache, compiler আর CPU-র out-of-order execution এই register-গুলোর সাথে কীভাবে আচরণ করবে।

৩ · যন্ত্রের ঠিকানা — port-mapped I/O বনাম memory-mapped I/O

CPU-র কাছে সব কিছু ঠিকানা। প্রশ্ন হলো, device register-এর ঠিকানা মেমরির ঠিকানার সাথে একই জগতে, না আলাদা জগতে?

Port-mapped I/O — আলাদা ঠিকানা-জগৎ (x86)

Port-mapped I/O-তে (isolated I/O-ও বলে) যন্ত্রের register থাকে একটি আলাদা “port” ঠিকানা-জগতে, আর তাদের ছোঁয়ার জন্য বিশেষ instruction. Intel 8080 থেকে এই ধারা x86-এ এসেছে: in আর out instruction, ১৬-বিটের port নম্বর — মোট ৬৫,৫৩৬টি byte-port. Bus-এ একটি আলাদা সংকেত (বা আলাদা ধরনের transaction) জানায় যে এটি মেমরি নয়, I/O. PC-র ঐতিহ্যগত প্রথম serial port (COM1) port 0x3F8 থেকে ৮টি port জুড়ে থাকে — এটি PC-যুগের প্রচলিত বিন্যাস।

        mov  dx, 0x3FD      ; COM1-এর LSR = 0x3F8 + 5
poll:   in   al, dx         ; port থেকে এক byte পড়া (মেমরি নয়!)
        test al, 0x20       ; বিট 5: THR খালি?
        jz   poll           ; না হলে আবার দেখা
        mov  dx, 0x3F8      ; THR = 0x3F8 + 0
        mov  al, 'A'
        out  dx, al         ; port-এ এক byte লেখা

Memory-mapped I/O — একই ঠিকানা-জগৎ (RISC-V, ARM)

Memory-mapped I/O (MMIO)-তে physical ঠিকানা-জগতের কিছু অংশ RAM নয়, যন্ত্রের জন্য রাখা। Address decoder (পর্ব ১২-এর address decoding) ঠিকানা দেখে ঠিক করে, অনুরোধটি RAM-এ যাবে না কোনো device-এ। ISA-তে কোনো বিশেষ I/O instruction লাগে না — সাধারণ lb/sb/lw/sw. RISC-V-এ port I/O বলে কিছুই নেই; ARM-এও নেই। এমনকি x86-এর আধুনিক যন্ত্রেও (PCIe GPU, NVMe, network card) প্রায় সব register MMIO দিয়ে; port I/O টিকে আছে মূলত পুরোনো সামঞ্জস্যের জন্য।

এই বিন্যাস একটি শেখানোর উদাহরণ। এটি QEMU-র RISC-V “virt” যন্ত্রের বিন্যাসের কাছাকাছি (সেখানে UART 0x10000000-এ আর RAM 0x80000000 থেকে বলে xv6-riscv-এর মতো শিক্ষামূলক OS-এর কোডে দেখা যায়), কিন্তু প্রতিটি বাস্তব board-এর নিজস্ব map থাকে — device tree বা datasheet-এ লেখা।

MMIO-র তিনটি সতর্কতা — cache, compiler আর CPU-র ক্রম

MMIO-তে load/store সাধারণ instruction, কিন্তু অংশ ২-এর চারটি বৈশিষ্ট্যের জন্য তিন স্তরে বিশেষ ব্যবস্থা লাগে।

1. Cache নয় (uncached). Status register cache-এ থাকলে CPU চিরকাল পুরোনো মান পড়বে, আর লেখা data register-এ না গিয়ে cache-এ বসে থাকবে। তাই device অঞ্চল চিহ্নিত থাকে uncached হিসেবে — প্রতিটি প্রবেশ সত্যিই যন্ত্র পর্যন্ত যায়। RISC-V-এ এটি ঠিক করে প্ল্যাটফর্মের physical memory attributes (PMA) — কোন ঠিকানা-পরিসর মেমরি, কোনটি I/O; ARM-এ page table-এর “Device” memory type (যেমন Device-nGnRnE); x86-এ MTRR আর PAT দিয়ে “UC” (uncacheable) ধরন।
2. Compiler যেন পড়া-লেখা বাদ না দেয় — volatile. লুপের ভেতরে কেউ status বদলায় না দেখে compiler -O2-এ পড়াটি একবারেই সেরে লুপকে অসীম বানাতে পারে। volatile বলে: প্রতিটি পড়া-লেখা সত্যিই আর ক্রমে করতে হবে। তবে এটি শুধু compiler-কে বাঁধে — CPU-কে নয়, আর এটি lock বা barrier নয় (Embedded C পর্বে ব্যবহার আছে)।
3. CPU-র ক্রম — fence. RISC-V-এর memory model (RVWMO) শিথিল: ভিন্ন ঠিকানার load/store CPU আগে-পরে দেখাতে পারে। ধরুন driver প্রথমে RAM-এ একটি কাজের বিবরণ (descriptor) লেখে, তারপর device-এর doorbell register-এ লেখে। Device যদি doorbell আগে দেখে, পুরোনো descriptor পড়বে। RISC-V-এর fence instruction-এ আগের আর পরের সেট আলাদা করে বলা যায় — I (device input, অর্থাৎ device-পড়া), O (device output, device-লেখা), R (মেমরি-পড়া), W (মেমরি-লেখা)। যেমন fence w, o মানে “আগের সব মেমরি-লেখা পরের যেকোনো device-লেখার আগে দৃশ্যমান হবে”। Linux-এর RISC-V port writel()-জাতীয় ফাংশনে এ ধরনের fence বসায় বলে জানা যায়; ঠিক কোন fence লাগবে, তা specification আর SoC-এর নথি দেখে নিশ্চিত হওয়া উচিত।

৪ · হাতে-কলমে MMIO — একটি UART-এ polling দিয়ে byte পাঠানো

সবচেয়ে সরল আর সবচেয়ে প্রচলিত যন্ত্র দিয়ে শুরু করি: UART, যা একটি একটি বিট করে serial লাইনে byte পাঠায় (ভেতরের shift register পর্ব ১৬-এ দেখেছেন)। ১৯৮০-এর দশকের National Semiconductor-এর 16550 chip-এর register-বিন্যাস এত ব্যাপকভাবে অনুকরণ করা হয়েছে যে আজও বহু SoC আর emulator “16550-ধাঁচের” UART দেয়। আমরা শুধু দরকারি অংশ নেব:

(+4, +6, +7-এ modem control, modem status আর একটি scratch register; আর LCR-এর একটি বিট বদলে +0/+1-এ baud rate-এর divisor লেখা হয় — এখানে লাগবে না।) Base ঠিকানা আমরা ধরব 0x10000000. তাহলে LSR-এর ঠিকানা = 0x10000000 + 5 = 0x10000005.

Polling-এ byte পাঠানোর নিয়ম দুই লাইনের: “LSR-এর THRE বিট ১ না হওয়া পর্যন্ত বারবার পড়ুন, তারপর THR-এ byte লিখুন।” C আর RISC-V-এ:

/* C */                                   # RV32I
#define UART ((volatile unsigned char *)0x10000000)
void uart_putc(char c) {                  uart_putc:
                                              lui   a5, 0x10000      # a5 = 0x10000000
    while ((UART[5] & 0x20) == 0)         1:  lbu   a4, 5(a5)        # LSR পড়া (uncached)
        ;              /* busy-wait */        andi  a4, a4, 0x20     # THRE বিট
                                              beqz  a4, 1b           # ০ হলে আবার
    UART[0] = c;                              sb    a0, 0(a5)        # THR-এ লেখা
}                                             ret

লক্ষ করুন, lbu a4, 5(a5) একটি সম্পূর্ণ সাধারণ load — পর্ব ২৬-এর base + offset ঠিকানা। পার্থক্য শুধু ঠিকানায়: decoder এটিকে RAM-এ না পাঠিয়ে UART-এ পাঠায়। এই ধরনের polling-কে busy-waiting-ও বলে: CPU কাজের কাজ কিছু না করে শুধু অপেক্ষা করে।

এখন stepper-এ দেখুন, একটি byte পাঠানোর সময় register-গুলোর ভেতরে কী ঘটে। আগের byte 'O' shift register-এ বেরোচ্ছে, তার পরের 'K' THR-এ অপেক্ষায়, আর CPU এখন '\n' (0x0A) পাঠাতে চায়। “পরে” চাপুন:

1while ((UART[5] & 0x20) == 0)   // LSR পড়া2    ;                           // আবার3    // THRE = 1, লুপ শেষ4UART[0] = '\n';                  // THR-এ লেখা5// (CPU এখন অন্য কাজে)

এবার একই ধারণা চালানো যায় এমন রূপে। নিচের JS-এ একটি ছোট “bus” আছে: 0x10000000-এর নিচে RAM, ওপরে ৮টি register-এর UART. প্রতিটি load/store সময় বাড়ায় (RAM ১ cycle — যেন cache hit; device-প্রবেশ ৬ cycle), আর THR-এ লেখার পর UART K = ৪০ cycle ব্যস্ত থাকে। (আসল UART-এর চেয়ে বহু গুণ ছোট সংখ্যা):

// A tiny bus: RAM below 0x10000000, a 16550-style UART at 0x10000000 (THR = +0, LSR = +5).
const UART = 0x10000000, THR = UART + 0, LSR = UART + 5, THRE = 0x20, K = 40;
const ram = new Map(); let now = 0, busyUntil = 0, sent = "";
function load8(a) {                                  // every access advances simulated time
  if (a >= UART && a < UART + 8) {                   // address decoder: device window, 8 regs
    now += 6;                                        // uncached device read: ~6 cycles here
    return a === LSR ? (now >= busyUntil ? THRE : 0) : 0;
  }
  now += 1; return ram.get(a) ?? 0;                  // RAM hit (pretend cache): 1 cycle
}
function store8(a, v) {
  if (a === THR) { now += 6; sent += String.fromCharCode(v); busyUntil = now + K; return; }
  now += 1; ram.set(a, v & 0xFF);
}
function putc(ch) {                                  // the polling transmit loop
  const t0 = now; let polls = 0;
  while ((load8(LSR) & THRE) === 0) polls++;         // busy-wait until THR is empty
  const waited = now - t0;
  store8(THR, ch.charCodeAt(0));
  return [polls, waited];
}
const msg = "Hi!\n";
for (let i = 0; i < msg.length; i++) store8(0x2000 + i, msg.charCodeAt(i));  // message in RAM
console.log("byte  polls_failed  cycles_waiting");
let total = 0;
for (let i = 0; i < msg.length; i++) {
  const ch = String.fromCharCode(load8(0x2000 + i));
  const [p, w] = putc(ch); total += w;
  console.log(JSON.stringify(ch).padEnd(6), String(p).padStart(12), String(w).padStart(15));
}
console.log(`sent ${JSON.stringify(sent)} in ${now} cycles; ${total} spent polling (${(100 * total / now).toFixed(1)}%)`);

byte  polls_failed  cycles_waiting
"H"               0               6
"i"               6              42
"!"               6              42
"\n"              6              42
sent "Hi!\n" in 164 cycles; 132 spent polling (80.5%)

এবার C-তে একই নকশা, তবে বাস্তব driver যেভাবে লেখে — register-গুলোকে একটি struct-এর field হিসেবে, আর সেই struct-এর দিকে একটি volatile pointer. এখানে আসল UART নেই, তাই struct থাকে সাধারণ মেমরিতে আর একটি ছোট ফাংশন (hw_tick) hardware-এর ভূমিকা নেয়। বাস্তব board-এ pointer-টি হতো (void *)0x10000000, আর hw_tick-এর কাজ যন্ত্র নিজেই করত:

// Device registers as a volatile struct. Here the "device" is ordinary memory and a
// helper plays the hardware's part; on a real board the pointer would be (void *)0x10000000.
#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
struct uart16550 {                     /* 16550-style layout, one byte per register */
    uint8_t thr;                       /* +0 transmit holding (write)               */
    uint8_t ier, fcr, lcr, mcr;        /* +1..+4 interrupt enable, FIFO, line, modem */
    uint8_t lsr, msr, scr;             /* +5 line status (bit 5 = THR empty), +6, +7 */
};
#define LSR_THRE 0x20u
_Static_assert(offsetof(struct uart16550, lsr) == 5, "LSR must sit at offset 5");
static struct uart16550 fake;          /* stands in for the device's address window  */
static unsigned busy;                  /* polls left until the fake byte is "sent"   */
static void hw_tick(void) {            /* what the hardware would do on its own      */
    if (busy && --busy == 0) fake.lsr |= LSR_THRE;
}
static unsigned uart_putc(volatile struct uart16550 *u, char c) {
    unsigned polls = 0;
    while ((u->lsr & LSR_THRE) == 0) { polls++; hw_tick(); }   /* re-read every time */
    u->thr = (uint8_t)c;               /* the store that starts transmission         */
    u->lsr &= (uint8_t)~LSR_THRE;      /* (the real chip clears THRE by itself)      */
    busy = 3;
    return polls;
}
int main(void) {
    volatile struct uart16550 *uart = &fake;
    fake.lsr = LSR_THRE;               /* idle: ready for the first byte             */
    printf("sizeof = %zu, offset of lsr = %zu\n", sizeof *uart, offsetof(struct uart16550, lsr));
    for (const char *p = "OK\n"; *p; p++) {
        unsigned n = uart_putc(uart, *p);
        printf("byte 0x%02X: %u failed polls, LSR now 0x%02X\n", (unsigned)(uint8_t)*p, n, (unsigned)uart->lsr);
    }
    return 0;
}

sizeof = 8, offset of lsr = 5
byte 0x4F: 0 failed polls, LSR now 0x00
byte 0x4B: 3 failed polls, LSR now 0x00
byte 0x0A: 3 failed polls, LSR now 0x00

৫ · Polling-এর দাম — কখন চলে, কখন চলে না; আর interrupt ও DMA

পাঠ্যবইয়ের প্রচলিত হিসাব: ডেটা না হারাতে CPU-কে সেকেন্ডে নির্দিষ্ট সংখ্যক বার poll করতে হবে, আর প্রতিটি poll-এ (call, uncached পড়া, তুলনা, ফেরা) নির্দিষ্ট cycle লাগে। তাহলে:

প্রতি সেকেন্ডে poll কত? ধীর যন্ত্রে একটি নির্দিষ্ট হার (mouse-এর অবস্থান সেকেন্ডে কয়েকশো বার দেখলেই যথেষ্ট); দ্রুত যন্ত্রে ডেটার হার ÷ প্রতি poll-এ কত byte সরানো যায়। হাতে একটি উদাহরণ: ২ GHz CPU, প্রতি poll ৪০০ cycle (ধরে নেওয়া মান)।

• Mouse, সেকেন্ডে ১০০০ বার: ১০০০ × ৪০০ = ৪ × ১০^৫ cycle/s → ৪ × ১০^৫ ÷ ২ × ১০^৯ = ০.০২%. নগণ্য।
• ১ Gbit/s network card, প্রতি poll-এ ৬৪ byte: ১২৫ × ১০^৬ byte/s ÷ ৬৪ = ১৯,৫৩,১২৫ poll/s × ৪০০ = ৭.৮১ × ১০^৮ → ৩৯.১%. শুধু অপেক্ষায় CPU-র এক-তৃতীয়াংশের বেশি!

নিচের calculator আরও কয়েকটি যন্ত্রে একই হিসাব করে। সব মান শেখানোর জন্য ধরে নেওয়া — বাস্তবের যন্ত্র ভিন্ন হবে:

// Fraction of CPU time spent polling. ALL device figures are ASSUMED teaching values.
const CLOCK = 2e9, POLL = 400;                        // 2 GHz CPU, 400 cycles per poll (assumed)
const devices = [
  // name, polls per second needed (rate / bytes per poll, or a fixed poll rate)
  ["mouse (1000 polls/s)",            1000],
  ["keyboard (100 polls/s)",           100],
  ["1 Gbit/s NIC, 64 B per poll",     125e6 / 64],
  ["SSD 2 GB/s, 4 KiB per poll",      2e9 / 4096],
  ["SSD 2 GB/s, 16 B per poll",       2e9 / 16],
];
const pct = x => (100 * x).toPrecision(3) + "%";
console.log(`CPU ${CLOCK / 1e9} GHz, ${POLL} cycles per poll`);
console.log("device".padEnd(30), "polls/s".padStart(12), "cycles/s".padStart(14), "CPU share".padStart(10));
for (const [name, pps] of devices) {
  const cyc = pps * POLL;
  console.log(name.padEnd(30), pps.toFixed(0).padStart(12), cyc.toExponential(2).padStart(14),
              (cyc > CLOCK ? "> 100%!" : pct(cyc / CLOCK)).padStart(10));
}
// Polling only while the device is busy: disk active 10% of the time
const active = 0.10, disk = 2e9 / 4096 * POLL / CLOCK;
console.log(`SSD 4 KiB polling, busy ${active * 100}% of the time -> ${pct(disk * active)}`);

CPU 2 GHz, 400 cycles per poll
device                              polls/s       cycles/s  CPU share
mouse (1000 polls/s)                   1000        4.00e+5    0.0200%
keyboard (100 polls/s)                  100        4.00e+4   0.00200%
1 Gbit/s NIC, 64 B per poll         1953125        7.81e+8      39.1%
SSD 2 GB/s, 4 KiB per poll           488281        1.95e+8      9.77%
SSD 2 GB/s, 16 B per poll         125000000       5.00e+10    > 100%!
SSD 4 KiB polling, busy 10% of the time -> 0.977%

দুটি বিকল্প, এক অনুচ্ছেদে — বিস্তারিত পর্ব ৫২-এ

Interrupt: CPU জিজ্ঞেস করে না; যন্ত্র কাজ শেষ হলে একটি তারে (বা PCIe-তে একটি বিশেষ বার্তায়) সংকেত পাঠায়, CPU দুটি instruction-এর মাঝে থেমে handler চালায়। অলস সময়ে খরচ শূন্য, কিন্তু প্রতিটি ঘটনায় context বাঁচানো-ফেরানোর খরচ (কয়েকশো থেকে কয়েক হাজার cycle) — খুব ঘন ঘটনায় এটিই আবার বোঝা। CPU-র দিক থেকে trap-এর পদ্ধতি পর্ব ৩৮-এ (Exception আর interrupt) দেখেছেন।

DMA (direct memory access): CPU যন্ত্রকে শুধু বলে “এই ঠিকানার ৬৪ KiB disk-এ লিখতে হবে” (বা মেমরিতে একটি descriptor রেখে doorbell বাজায়); যন্ত্রের DMA engine নিজেই bus-এর master হয়ে মেমরি থেকে পড়ে বা লেখে, আর শেষে একটি interrupt দেয়। CPU-র খরচ এখন প্রতি byte-এ নয়, প্রতি কাজে। Interrupt-এর বিস্তারিত, interrupt controller, MSI, DMA-র descriptor ring, cache coherence আর IOMMU — সব পর্ব ৫২-এ (Interrupt আর DMA — hardware-এর দিক থেকে)।

৬ · Bus — তার, সময়, arbitration আর bandwidth; parallel থেকে serial

Bus হলো কয়েকটি অংশের মধ্যে ভাগ করা যোগাযোগের পথ — এক গুচ্ছ তার আর তাদের ব্যবহারের নিয়ম (protocol). ক্লাসিক bus-এর তারগুলো তিন দলে:

• Address লাইন: কোন ঠিকানা (কোন মেমরি-ঘর বা কোন device register).
• Data লাইন: আসল ডেটা — ৮, ১৬, ৩২ বা ৬৪টি তার একসাথে; এই সংখ্যাই bus-এর width.
• Control লাইন: পড়া না লেখা, মেমরি না I/O, clock, “ডেটা বৈধ”, “তৈরি”, অনুরোধ আর অনুমতির সংকেত।

Synchronous বনাম asynchronous bus

Synchronous bus-এ সবাই একটি সাধারণ clock মেনে চলে: “clock-এর তৃতীয় edge-এ ডেটা তৈরি থাকবে”। নকশা সরল আর দ্রুত, কিন্তু সবচেয়ে ধীর যন্ত্রকেও সেই সময়ে উত্তর দিতে হয় (নাহলে “wait” সংকেত দিয়ে বাড়তি cycle চাইতে হয়), আর লম্বা তারে clock skew (পর্ব ১৮) বাড়ে বলে দৈর্ঘ্য সীমিত। Asynchronous bus-এ কোনো সাধারণ clock নেই; দুই পক্ষ handshake-এ কথা বলে — চার ধাপের REQ/ACK:

          (1)          (2)          (3)          (4)
REQ   ____/‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\_______________________
ACK   _________________/‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\__________
DATA  ====<        বৈধ ডেটা          >=========================
(1) পাঠানো পক্ষ ডেটা বসিয়ে REQ তোলে   (2) গ্রহীতা ডেটা ধরে ACK তোলে
(3) পাঠানো পক্ষ REQ নামায়            (4) গ্রহীতা ACK নামায় — পরের চক্র তৈরি

ধীর যন্ত্র ধীরে ACK দেয়, দ্রুত যন্ত্র দ্রুত — সময় আপনা থেকে মিলে যায়। দাম: প্রতিটি transfer-এ তারের দুই দিকে চারবার যাওয়া-আসা।

Bus arbitration — কে চালাবে?

একাধিক অংশ (CPU, DMA-সক্ষম যন্ত্র) bus-এর master হতে চাইলে bus arbitration লাগে। দুটি ক্লাসিক পদ্ধতি:

• Daisy chain: অনুমতির (grant) একটি তার যন্ত্র থেকে যন্ত্রে শিকলের মতো যায়। যে যন্ত্র অনুরোধ করেছে, সে grant আটকে রাখে; না করলে পরের জনকে দেয়। তার কম, কিন্তু অগ্রাধিকার জায়গায় বাঁধা — শিকলের শুরুর যন্ত্র সবসময় জেতে, শেষের যন্ত্র অনাহারে (starvation) থাকতে পারে।
• কেন্দ্রীয় (centralised) arbiter: প্রতিটি যন্ত্রের নিজস্ব request ও grant তার একটি arbiter-এ যায়, যে নীতি (নির্দিষ্ট অগ্রাধিকার, round-robin) মেনে বেছে নেয়। ন্যায্য, কিন্তু তার বেশি। ক্লাসিক PCI এই ধরনের ছিল।

Bandwidth-এর হিসাব

ক্লাসিক PCI: ৩২ বিট = ৪ byte, প্রায় ৩৩.৩৩ MHz, প্রতি clock-এ ১টি transfer → ৪ × ৩৩.৩৩ × ১০^৬ ≈ ১৩৩ MB/s — এটি সর্বোচ্চ (peak) মান। বাস্তবে address-এর cycle, অপেক্ষা আর arbitration-এ কিছু cycle যায়: যদি প্রতি ৪টি data cycle-এর জন্য ১টি address cycle আর ১টি turnaround লাগে, তাহলে কার্যকর মান peak-এর ৪/৬. DDR মেমরি (পর্ব ৪৯) clock-এর দুই edge-এই transfer করে, তাই “প্রতি clock-এ ২”।

Parallel থেকে serial — কেন?

PC-তে ছিল ISA bus (১৯৮১ সালের IBM PC-তে ৮ বিট, পরে ১৬ বিট), তারপর ১৯৯০-এর দশকে PCI. গতি বাড়ানোর স্বাভাবিক পথ — আরও চওড়া, আরও দ্রুত clock — শত MHz-এ তিনটি দেয়ালে ঠেকে:

• Skew: সব তারের সংকেত ঠিক একসাথে পৌঁছায় না; clock যত দ্রুত, এই আগে-পিছে বিটের সময়ের তত বড় অংশ খায়।
• Crosstalk: পাশাপাশি তারে দ্রুত বদলানো সংকেত একে অপরের ওপর বৈদ্যুতিক প্রভাব ফেলে।
• Pin আর জায়গা: প্রতিটি বাড়তি তার মানে chip-এ pin, board-এ পথ, connector-এ পিন — খরচ আর শক্তি।

সমাধান: কম তার, অনেক দ্রুত। আধুনিক serial link-এ প্রতিটি দিকে একটি differential pair (দুটি তারে উল্টো সংকেত, যাতে বাইরের গোলমাল কাটাকাটি হয়), আর clock আলাদা তারে যায় না — গ্রহীতা ডেটার বিট-বদল থেকেই clock পুনরুদ্ধার করে (clock recovery). তার জন্য ডেটায় যথেষ্ট ০↔১ বদল থাকা চাই — সেটিই line encoding-এর কাজ: 8b/10b মানে প্রতি ৮ বিট ডেটা পাঠানো হয় ১০ বিটের code হিসেবে (তারের বিটের ২০% বাড়তি), 128b/130b মানে প্রতি ১২৮ বিটে মাত্র ২ বিটের মাথা (তারের বিটের প্রায় ১.৫৪%, তবে ডেটা scramble করে বিট-বদল নিশ্চিত করা হয়)। Signalling আর encoding-এর মৌলিক ধারণা Computer Networks কোর্সের Physical layer পর্বে আছে। প্রতিটি lane-এর clock আলাদাভাবে পুনরুদ্ধার হয়, আর lane-গুলোর মধ্যের skew গ্রহীতা নিজে মেলায়। এর hardware অংশ SerDes (serializer/deserializer).

নিচের calculator দুই ধরনের সংযোগের raw আর কার্যকর bandwidth হিসাব করে। Serial-এর ক্ষেত্রে GT/s মানে প্রতি সেকেন্ডে কত বিলিয়ন transfer (তারে বিট), তার থেকে encoding বাদ দিয়ে আসল ডেটা। সব মান প্রতি দিকে, আর packet-এর header-এর খরচ ধরা হয়নি:

// Raw vs effective bandwidth of parallel buses and serial links (per direction).
// Parallel: width (bits) x clock (MHz) x transfers per clock.  Serial: GT/s x lanes x encoding.
const MBs = x => x >= 1000 ? (x / 1000).toFixed(2) + " GB/s" : x.toFixed(1) + " MB/s";
console.log("Parallel bus                 width  clock MHz  xfer/clk  bandwidth");
for (const [name, bits, mhz, xfer] of [
  ["PCI (classic)",              32,  33.33, 1],
  ["PCI-X 133",                  64, 133.33, 1],
  ["DDR4-3200 channel",          64, 1600,   2],
]) console.log(name.padEnd(28), String(bits).padStart(5), String(mhz).padStart(10),
               String(xfer).padStart(9), " " + MBs(bits / 8 * mhz * xfer));

console.log("\nSerial link                  GT/s lanes encoding      raw      effective");
for (const [name, gt, lanes, enc, [d, t]] of [
  ["PCIe Gen1 x1",          2.5,  1, "8b/10b",    [8, 10]],
  ["PCIe Gen2 x8",          5,    8, "8b/10b",    [8, 10]],
  ["PCIe Gen3 x4",          8,    4, "128b/130b", [128, 130]],
  ["PCIe Gen3 x16",         8,   16, "128b/130b", [128, 130]],
  ["PCIe Gen4 x4",         16,    4, "128b/130b", [128, 130]],
  ["SATA 6 Gb/s",           6,    1, "8b/10b",    [8, 10]],
  ["USB 5 Gb/s (Gen 1)",    5,    1, "8b/10b",    [8, 10]],
  ["USB 10 Gb/s (Gen 2)",  10,    1, "128b/132b", [128, 132]],
]) {
  const raw = gt * lanes * 1000 / 8, eff = raw * d / t;          // MB/s, before packet overhead
  console.log(name.padEnd(26), String(gt).padStart(6), String(lanes).padStart(4), enc.padStart(10),
              MBs(raw).padStart(11), MBs(eff).padStart(13), `(${(100 * d / t).toFixed(2)}%)`);
}

Parallel bus                 width  clock MHz  xfer/clk  bandwidth
PCI (classic)                   32      33.33         1  133.3 MB/s
PCI-X 133                       64     133.33         1  1.07 GB/s
DDR4-3200 channel               64       1600         2  25.60 GB/s

Serial link                  GT/s lanes encoding      raw      effective
PCIe Gen1 x1                  2.5    1     8b/10b  312.5 MB/s    250.0 MB/s (80.00%)
PCIe Gen2 x8                    5    8     8b/10b   5.00 GB/s     4.00 GB/s (80.00%)
PCIe Gen3 x4                    8    4  128b/130b   4.00 GB/s     3.94 GB/s (98.46%)
PCIe Gen3 x16                   8   16  128b/130b  16.00 GB/s    15.75 GB/s (98.46%)
PCIe Gen4 x4                   16    4  128b/130b   8.00 GB/s     7.88 GB/s (98.46%)
SATA 6 Gb/s                     6    1     8b/10b  750.0 MB/s    600.0 MB/s (80.00%)
USB 5 Gb/s (Gen 1)              5    1     8b/10b  625.0 MB/s    500.0 MB/s (80.00%)
USB 10 Gb/s (Gen 2)            10    1  128b/132b   1.25 GB/s     1.21 GB/s (96.97%)

৭ · PCI Express — lane, packet, root complex আর BAR

PCI Express (PCIe) আজকের PC, server আর অনেক SoC-এর প্রধান দ্রুত সংযোগ: GPU, NVMe SSD, network card, এমনকি chip-এর ভেতরের কিছু অংশ। ২০০০-এর দশকের শুরুতে এটি PCI-র উত্তরসূরি হিসেবে আসে। নাম PCI-র মতো, আর software-এর দিক থেকে (configuration-এর নিয়ম, BAR) PCI-র সাথে সামঞ্জস্য রাখা হয়েছে — কিন্তু তারের স্তরে এটি সম্পূর্ণ ভিন্ন: ভাগ করা bus নয়, প্রতিটি যন্ত্রের সাথে নিজস্ব point-to-point serial link.

Lane আর link-এর চওড়া

একটি lane = দুটি differential pair — একটি পাঠানোর, একটি গ্রহণের; তাই দুই দিকে একসাথে পূর্ণ গতি (full duplex). একটি link-এ ১, ২, ৪, ৮ বা ১৬টি lane থাকতে পারে, লেখা হয় x1, x4, x8, x16 (“by sixteen”). ডেটা lane-গুলোতে byte ধরে ভাগ করে (striping) পাঠানো হয়। Graphics card সাধারণত x16 slot-এ, NVMe SSD সাধারণত x4-এ, ছোট network বা USB controller x1-এ বসে। শুরুতে দুই প্রান্ত link training-এ ঠিক করে কত lane আর কোন গতি।

প্রতিটি প্রজন্মে প্রতি lane-এর কার্যকর হার মোটামুটি দ্বিগুণ হয়েছে। Gen6-এ (৬৪ GT/s) signalling বদলে PAM4 (প্রতি চিহ্নে ২ বিট) আর error correction-সহ নির্দিষ্ট মাপের “FLIT” packet আসে, যেখানে 128b/130b আর প্রযোজ্য নয় বলে জানা যায় — তাই এই টেবিলের সরল হিসাব সেখানে খাটে না। বিজ্ঞাপনে প্রায়ই দুই দিক যোগ করা সংখ্যা থাকে; উত্তরে বলবেন, প্রতি দিকে না দুই দিক মিলিয়ে।

Packet দিয়ে কথা — তিন স্তর

PCIe-তে কোনো address বা data “লাইন” নেই; সব কিছু packet. স্তরগুলো নেটওয়ার্কের মতো:

• Transaction layer: TLP (transaction layer packet) বানায় — memory read, memory write, configuration read/write, completion (পড়ার উত্তর), আর বার্তা বা message TLP (যেমন পুরোনো INTx interrupt-তারের অনুকরণ). লক্ষ করুন, MSI interrupt কোনো বিশেষ বার্তা নয় — আসলে একটি সাধারণ memory write. Memory write সাধারণত posted — পাঠিয়েই শেষ, উত্তরের অপেক্ষা নেই। Memory read non-posted — উত্তর আসে আলাদা completion TLP-তে, তাই MMIO-পড়া লেখার চেয়ে অনেক দেরিতে শেষ হয়।
• Data link layer: প্রতিটি TLP-তে sequence নম্বর আর একটি CRC (LCRC) যোগ করে; গ্রহীতা ঠিক পেলে ACK, ভুল পেলে NAK পাঠায়, আর পাঠানো পক্ষ একটি replay buffer থেকে আবার পাঠায়। Software জানে না (CRC-র ধারণা Error detection পর্বে)।
• Physical layer: encoding (128b/130b), scrambling, lane-এ ভাগ, serialize করে তারে পাঠানো।

Topology — root complex, switch, endpoint

PCIe একটি গাছ। গোড়ায় root complex — CPU/মেমরির দিক আর PCIe-র দিকের মাঝের সেতু, আজকাল সাধারণত CPU chip বা SoC-এর ভেতরেই। তার এক বা একাধিক root port; প্রতিটিতে একটি link. Link-এর ওপাশে হয় একটি endpoint (আসল যন্ত্র — GPU, SSD), নয়তো একটি switch, যা একটি ওপরের (upstream) port থেকে কয়েকটি নিচের (downstream) port বানায়, যেন বিদ্যুতের মাল্টিপ্লাগ, আর প্রতিটি port-এর ঠিকানা-পরিসর (base/limit) দেখে TLP পাঠায়।

Enumeration আর BAR — MMIO জানালা কোথায় বসবে

প্রতিটি PCIe function-এর একটি configuration space আছে (PCI-তে ২৫৬ byte, PCIe-তে ৪ KiB): vendor ID, device ID, class code আর BAR (base address register). প্রতিটি function-এর ঠিকানা BDF — bus (৮ বিট), device (৫ বিট), function (৩ বিট)। Boot-এর সময় firmware বা OS enumeration করে: প্রতিটি সম্ভাব্য BDF-এর config space পড়ে দেখে কে আছে, switch পেলে নিচে নতুন bus নম্বর দেয়, আর প্রতিটি BAR ঠিক করে।

BAR বলে, যন্ত্রটি তার register-এর জন্য কত বড় ঠিকানা-জানালা চায়। আকার জানার কৌশলটি চতুর: software BAR-এ সব বিট ১ (0xFFFFFFFF) লেখে, তারপর পড়ে। যন্ত্র যে বিটগুলো বদলাতে দেয় না, সেগুলো ০ ফেরে। Memory BAR-এর নিচের ৪টি বিট flag (বিট ০ = ০ মানে memory, বিট ২–১ ধরন — ৩২ বা ৬৪ বিট, বিট ৩ prefetchable); সেগুলো মুছে বাকিটার উল্টো + ১ = আকার। যেমন পড়া মান 0xFFFFC000 → আকার = ~0xFFFFC000 + 1 = 0x4000 = ১৬ KiB. তারপর software একটি ১৬ KiB-aligned ঠিকানা (যেমন 0xFE000000) BAR-এ লেখে — এখন থেকে CPU-র 0xFE000000–0xFE003FFF-এ load/store সরাসরি যন্ত্রের register-এ যায়। অংশ ৩-এর memory-mapped I/O এভাবেই PCIe যন্ত্রে বসে।

এবার stepper-এ একটি NVMe-ধাঁচের যন্ত্রের doorbell register-এ CPU-র একটি store-এর পুরো যাত্রা (ধারণাগত; বাস্তব chip-এ fabric-এর নাম আর খুঁটিনাটি ভিন্ন):

sw   a1, 8(a0)        # a0 = doorbell অঞ্চলের শুরুর VA, a1 = নতুন tail = 5
MMU: VA -> PA 0xFE001008, page-টি I/O (uncached)
cache-এ যাবে না; store buffer থেকে ক্রমমতো বেরোবে

0x80000000.. : DRAM            না
0xFE000000.. : PCIe MMIO জানালা  হ্যাঁ
অনুরোধ যায় root complex-এ (memory controller-এ নয়)

ধরন    : Memory Write (MWr), 32-bit ঠিকানা
ঠিকানা : 0xFE001008   দৈর্ঘ্য: 1 DW (4 byte)
ডেটা   : 0x00000005
posted : উত্তর (completion) আসবে না

[seq 0x2A1][ TLP header + data ][LCRC 32-bit]
কপি থাকে replay buffer-এ, ACK না আসা পর্যন্ত
NAK বা timeout হলে আবার পাঠানো হয়

byte 0 -> lane 0, byte 1 -> lane 1, ... (striping)
প্রতি lane: scramble, 128b/130b block, serialize
৮ GT/s প্রতি lane, দুই দিকে আলাদা জোড়া

downstream port 1: 0xE0000000-0xEFFFFFFF  না
downstream port 2: 0xFE000000-0xFE0FFFFF  হ্যাঁ
TLP যায় port 2-এ; ACK ফেরে প্রতিটি link-এ আলাদা

BAR0 = 0xFE000000, আকার 16 KiB  -> মিলেছে
offset = 0x1008 -> submission queue 1-এর tail doorbell
যন্ত্র মেমরি থেকে নতুন কাজ পড়তে শুরু করে (DMA, পর্ব ৫২)

৮ · USB, আর অন্যান্য সংযোগ — SATA, NVMe, I2C, CXL; chipset আর SoC

USB — host-নিয়ন্ত্রিত tiered star

USB (Universal Serial Bus) এসেছিল ১৯৯০-এর দশকের মাঝামাঝি, PC-র পেছনের নানা রকম port (serial, parallel, কীবোর্ড-mouse-এর আলাদা port) একটি সাধারণ, plug-and-play সংযোগে বদলাতে। তার নকশার মূল কথাগুলো:

• Host সব নিয়ন্ত্রণ করে। Host controller সব transfer-এর সময়সূচি বানায়; device শুধু জিজ্ঞেস করলে উত্তর দেয়। “Interrupt transfer”-ও আসলে host-এর নির্দিষ্ট বিরতিতে polling.
• Tiered star. Host-এর root hub থেকে hub, hub থেকে আরও hub বা device — গাছের মতো স্তরে স্তরে। একটি bus-এ ৭-বিট ঠিকানা, তাই সর্বোচ্চ ১২৭টি device; স্তরের সংখ্যাও মান অনুযায়ী সীমিত।
• Endpoint আর চার ধরনের transfer. প্রতিটি device-এর ভেতরে কয়েকটি endpoint — ডেটার আলাদা “জানালা”; endpoint 0 সবসময় control-এর জন্য।

গতি আর নামের জট. নামগুলো সত্যিই বিভ্রান্তিকর, তাই সংখ্যা দিয়ে মনে রাখাই নিরাপদ। USB 1.x: Low Speed ১.৫ Mbit/s আর Full Speed ১২ Mbit/s. USB 2.0 (২০০০ সালের দিকে): High Speed ৪৮০ Mbit/s. USB 3.0 নিয়ে আসে ৫ Gbit/s (“SuperSpeed”, 8b/10b encoding) — পরে এই একই গতির নাম বদলে হয় “USB 3.1 Gen 1”, তারপর “USB 3.2 Gen 1”. ১০ Gbit/s (128b/132b) = “USB 3.1 Gen 2” = “USB 3.2 Gen 2”; দুই lane মিলিয়ে ২০ Gbit/s = “USB 3.2 Gen 2x2”. USB4 ২০ বা ৪০ Gbit/s, আর তার পরের সংস্করণে আরও বেশি বলে ঘোষণা হয়েছে। তাই বাক্সে শুধু “USB 3.2” দেখলে গতি নিশ্চিত নয় — সংখ্যায় লেখা গতি (“USB 10Gbps”) খুঁজুন।

USB-C সংযোগকারী, protocol নয়. USB-C শুধু প্লাগ আর সকেটের আকার (দুই দিকেই ঢোকানো যায়)। একটি USB-C তার বা port USB 2.0-এর গতিতে চলতে পারে, ১০ Gbit/s-এ চলতে পারে, বা Thunderbolt/USB4, DisplayPort-এর সংকেতও বহন করতে পারে — নির্ভর করে port, তার আর device তিনটিই কী সমর্থন করে তার ওপর।

একটি USB mouse লাগালে host কীভাবে তাকে চেনে — enumeration-এর ধাপগুলো ধারণাগত স্তরে:

অন্যান্য সংযোগ, সংক্ষেপে

• SATA আর NVMe: SATA হার্ড ডিস্কের যুগের serial সংযোগ (১.৫, ৩, ৬ Gbit/s; 8b/10b-এ সর্বোচ্চ প্রায় ৬০০ MB/s), সাধারণত AHCI নামের controller-নিয়মে, যেখানে একটি command queue-তে সর্বোচ্চ ৩২টি কাজ। NVMe কোনো আলাদা তার নয় — PCIe-র ওপর চলা একটি protocol, flash-এর জন্য নতুন করে নকশা করা: মেমরিতে submission আর completion queue-র জোড়া, প্রতিটি CPU core-এর নিজস্ব queue রাখা যায়, আর মান অনুযায়ী queue-র সংখ্যা ও গভীরতা দুটিই হাজারের ঘরে (প্রায় ৬৪ হাজার পর্যন্ত বলে উল্লেখ করা হয়)।
• I2C, SPI, UART — embedded জগৎ: sensor, EEPROM, ছোট display-এর জন্য কয়েক তারের ধীর bus. I2C-তে দুটি তার (ডেটা আর clock), ঠিকানা দিয়ে অনেক যন্ত্র একই জোড়ায়; SPI-তে আলাদা clock আর chip-select, দ্রুত কিন্তু তার বেশি। বিস্তারিত পর্ব ৫৬-এ (Power, energy আর embedded সিস্টেম)।
• Thunderbolt আর USB4: একটি তারের ভেতরে PCIe, DisplayPort আর USB-এর ট্রাফিক packet আকারে “tunnel” করে নেওয়ার প্রযুক্তি; Thunderbolt 3 থেকে USB-C সংযোগকারী, আর USB4 তার protocol-এর ভিত্তিতে তৈরি বলে জানা যায়।
• CXL: PCIe-এর ভৌত স্তরের ওপর তিনটি protocol (CXL.io, CXL.cache, CXL.mem) — accelerator-কে CPU-র cache-এর সাথে coherent রাখা, আর বাইরের মেমরি load/store দিয়ে ব্যবহার। মেমরি হায়ারার্কির নতুন স্তর হিসেবে এর ধারণা পর্ব ৪৪-এ (মেমরি হায়ারার্কি আর locality).

Chipset থেকে SoC — একটি আধুনিক যন্ত্রের মানচিত্র

২০০০-এর দশকের PC-তে CPU-র পাশে থাকত “northbridge” (memory controller, গ্রাফিক্স) আর “southbridge” (USB, SATA, অডিও). পরে memory controller আর দ্রুত PCIe lane CPU chip-এর ভেতরে চলে আসে; Intel-এর PC-তে ধীর I/O থাকে একটি platform controller hub (PCH)-এ। ফোন আর অনেক ল্যাপটপে প্রায় সবকিছু একটি SoC-এ। নির্মাতাভেদে ভাগ ভিন্ন, তবে মোটামুটি ছবিটি এমন:

৯ · I/O-র পারফরম্যান্স — latency, throughput আর Little-এর সূত্র

I/O-র গতি মাপার দুটি আলাদা প্রশ্ন আছে (পর্ব ০৩-এর latency বনাম throughput):

• Latency: একটি অনুরোধের শুরু থেকে শেষ — যেমন একটি ৪ KiB পড়া SSD থেকে কত µs-এ আসে। মানুষ যে “ধীর” অনুভব করে, তা সাধারণত latency.
• Throughput: প্রতি সেকেন্ডে কত কাজ বা কত byte — যেমন IOPS (প্রতি সেকেন্ডে I/O অনুরোধ) বা MB/s. Server-এর ক্ষমতা সাধারণত throughput-এ মাপা হয়।

দুটিকে জোড়ে একটি সরল কিন্তু খুব শক্তিশালী সূত্র — Little-এর সূত্র:

শর্ত শুধু স্থিতিশীল অবস্থা (গড়ে যত কাজ ঢোকে, তত বেরোয়); আগমনের ধরন বা সেবার নিয়ম যাই হোক, সূত্র খাটে। একটি সহজ যুক্তি: দীর্ঘ T সময়ে মোট λT-টি কাজ আসে, প্রতিটি গড়ে W সময় ভেতরে থাকে, তাই “কাজ × সময়”-এর মোট যোগফল λT × W; এটিকে T দিয়ে ভাগ করলে যেকোনো মুহূর্তে গড়ে ভেতরে থাকা কাজ = λW.

উদাহরণ ১ — queue depth. একটি NVMe SSD-র একটি ৪ KiB পড়ার latency প্রায় ১০০ µs (ধরে নেওয়া)। একটি প্রোগ্রাম যদি একটি করে অনুরোধ পাঠায় আর উত্তরের অপেক্ষা করে (L = ১), তাহলে λ = L ÷ W = ১ ÷ ১০০ µs = ১০,০০০ IOPS = ১০,০০০ × ৪০৯৬ byte ≈ ৪০.৯৬ MB/s — যে SSD কয়েক GB/s দিতে পারে, তার একটি ক্ষুদ্র অংশ। ৫,০০,০০০ IOPS পেতে হলে একসাথে চালু থাকা অনুরোধ L = ৫ × ১০^৫ × ১০০ × ১০^−৬ = ৫০টি (তখন ২.০৪৮ GB/s) — অবশ্যই যদি latency না বাড়ে। এ কারণেই NVMe-তে গভীর, বহু queue; আর এ কারণেই একটি thread-এর synchronous পড়া দ্রুত SSD-কেও ধীর দেখায়।

উদাহরণ ২ — link-এ. PCIe-র প্রতি দিকে ১৫.৭৫ GB/s আর একটি read-এর আসা-যাওয়া ১ µs ধরলে, link ব্যস্ত রাখতে একসাথে উড়ন্ত ডেটা লাগে প্রায় ১৫.৭৫ KB — তাই যন্ত্র একসাথে অনেক read অনুরোধ পাঠায় (network-এর একই ধারণা: Delay আর throughput).

১০ · AI-এর যুগে — I/O আর bus-এর হিসাবে AI, আর যাচাইয়ের অভ্যাস

AI টুল driver-এর কাঠামো আর ধারণা ভালো ব্যাখ্যা করে, কিন্তু I/O-তে সংখ্যা, একক আর register-এর খুঁটিনাটিতে প্রায়ই আত্মবিশ্বাসী ভুল করে। এই বিষয়ে সবচেয়ে বেশি দেখা যায়:

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

• Register-এর offset আর বিটের মান datasheet বা emulator-এর উৎসের সাথে মিলিয়েছি
• Polling লুপের পড়া volatile দিয়ে করা হয়েছে, আর মেমরি-লেখা ও device-লেখার মাঝে দরকারি fence আছে কি না দেখেছি
• Bandwidth-এর হিসাবে বিট আর byte, GT/s আর GB/s, প্রতি দিক আর দুই দিক আলাদা রেখেছি
• PCIe প্রজন্ম অনুযায়ী ঠিক encoding বসিয়েছি, আর calculator-এ মিলিয়েছি
• Polling-এর শতাংশ নিজে হাতে (poll/s × cycle ÷ clock) বের করেছি
• নির্দিষ্ট chip বা board-এর ঠিকানা ও গতির দাবি তার নিজস্ব নথিতে খুঁজেছি — বানানো ঠিকানায় কোড চালাইনি