KVM ও QEMU — kernel-ই hypervisor, userspace-ই বাকি সব হার্ডওয়্যার

এই স্ক্রিপ্টটা আসলেই চালানো হয়েছে (এই sandbox macOS, /dev/kvm নেই বলে সরাসরি KVM কল করা যায়নি — কিন্তু এই গণনাটা কোনো kernel access লাগে না, তাই পুরোপুরি verify-করা, real output):

# kvm_qemu_iotrip.py
# Model: কতগুলো userspace round-trip (VM-exit -> QEMU device model handle
# -> VM-entry, অর্থাৎ আরেকটা ioctl(KVM_RUN) কল) একটা device-I/O-ভারী
# workload-এর লাগে — legacy ATA/IDE PIO (পূর্ণ device emulation) বনাম
# virtio-blk (paravirtual, batched)।

import math

def ata_pio_exits_per_sector(lba_bytes=3, status_polls=4):
    select_drive_head = 1
    sector_count = 1
    lba_regs = lba_bytes
    command = 1
    polling = status_polls
    data_words = 512 // 2  # ২৫৬ — প্রতি ১৬-বিট শব্দে একটা IN
    return select_drive_head + sector_count + lba_regs + command + polling + data_words

def kvm_round_trips(n_sectors, exits_per_sector):
    n_exits = n_sectors * exits_per_sector
    ioctl_kvm_run_calls = n_exits + 1  # +১ প্রথম VM-entry-র জন্য
    return n_exits, ioctl_kvm_run_calls

def virtio_round_trips(n_sectors, sectors_per_batch):
    n_batches = math.ceil(n_sectors / sectors_per_batch)
    n_exits = n_batches  # এক "kick" (eventfd/MMIO doorbell) প্রতি ব্যাচে
    ioctl_kvm_run_calls = n_exits + 1
    return n_exits, ioctl_kvm_run_calls

EXIT_ENTRY_OVERHEAD_NS = 1200  # প্রকাশিত VT-x round-trip খরচের order-of-magnitude

if __name__ == "__main__":
    exits_per_sector = ata_pio_exits_per_sector()
    print(f"emulated ATA PIO: VM-exits per 512B sector = {exits_per_sector}")
    print()

    print("emulated ATA/IDE (PIO mode, full device emulation):")
    for n_sectors in (1, 100, 10_000, 1_000_000):
        n_exits, calls = kvm_round_trips(n_sectors, exits_per_sector)
        total_ms = n_exits * EXIT_ENTRY_OVERHEAD_NS / 1e6
        print(f"  sectors={n_sectors:>9,}  vm-exits={n_exits:>13,}  "
              f"ioctl(KVM_RUN) calls={calls:>13,}  overhead~{total_ms:>10.2f} ms")

    print()
    print("virtio-blk (paravirtual, batch of 128 sectors/request):")
    for n_sectors in (1, 100, 10_000, 1_000_000):
        n_exits, calls = virtio_round_trips(n_sectors, 128)
        total_ms = n_exits * EXIT_ENTRY_OVERHEAD_NS / 1e6
        print(f"  sectors={n_sectors:>9,}  vm-exits={n_exits:>13,}  "
              f"ioctl(KVM_RUN) calls={calls:>13,}  overhead~{total_ms:>10.4f} ms")

    print()
    n = 10_000
    ata_exits, _ = kvm_round_trips(n, exits_per_sector)
    vio_exits, _ = virtio_round_trips(n, 128)
    print(f"at {n:,} sectors: {ata_exits/vio_exits:.1f}x fewer VM-exits with virtio batching "
          f"({ata_exits:,} vs {vio_exits:,})")

প্রকৃত, চালানো output (Python 3.9, এই sandbox-এ হুবহু এই কমান্ডে পাওয়া গেছে — কোনো hand-trace না):

emulated ATA PIO: VM-exits per 512B sector = 266

emulated ATA/IDE (PIO mode, full device emulation):
  sectors=        1  vm-exits=          266  ioctl(KVM_RUN) calls=          267  overhead~      0.32 ms
  sectors=      100  vm-exits=       26,600  ioctl(KVM_RUN) calls=       26,601  overhead~     31.92 ms
  sectors=   10,000  vm-exits=    2,660,000  ioctl(KVM_RUN) calls=    2,660,001  overhead~   3192.00 ms
  sectors=1,000,000  vm-exits=  266,000,000  ioctl(KVM_RUN) calls=  266,000,001  overhead~ 319200.00 ms

virtio-blk (paravirtual, batch of 128 sectors/request):
  sectors=        1  vm-exits=            1  ioctl(KVM_RUN) calls=            2  overhead~    0.0012 ms
  sectors=      100  vm-exits=            1  ioctl(KVM_RUN) calls=            2  overhead~    0.0012 ms
  sectors=   10,000  vm-exits=           79  ioctl(KVM_RUN) calls=           80  overhead~    0.0948 ms
  sectors=1,000,000  vm-exits=        7,813  ioctl(KVM_RUN) calls=        7,814  overhead~    9.3756 ms

at 10,000 sectors: 33670.9x fewer VM-exits with virtio batching (2,660,000 vs 79)

সংখ্যাগুলো নিজেরাই কথা বলছে — মাত্র ১০,০০০ সেক্টর (৫ মেগাবাইটেরও কম!) পড়তে emulated ATA PIO মোডে ২৬ লাখেরও বেশি VM-exit লাগে, শুধু exit/entry overhead-এই আনুমানিক ৩.২ সেকেন্ড — অথচ একই ডেটা batched virtio মডেলে মাত্র ৭৯টা exit, ০.১ মিলিসেকেন্ডেরও কম overhead। ৩৩,৬৭০ গুণ পার্থক্য, শুধু “কীভাবে ডেটা রিকোয়েস্ট ব্যাচ করা হয়েছে” তার কারণে — CPU নিজে ঠিক একই গতিতে চলছে দুই ক্ষেত্রেই (KVM-accelerated), পার্থক্যটা সম্পূর্ণ device-interaction প্যাটার্নে। এই একটা সংখ্যাই পরের লেসনের (paravirtualization) পুরো justification।

(EXIT_ENTRY_OVERHEAD_NS = 1200 একটা রক্ষণশীল, প্রকাশিত-সাহিত্য-ভিত্তিক order-of-magnitude ধরে নেওয়া মান — বাস্তব সংখ্যা CPU generation, mitigation (Spectre/Meltdown patch) সক্রিয় কি না, ইত্যাদির উপর নির্ভর করে কয়েকশ থেকে কয়েক হাজার ন্যানোসেকেন্ডের মধ্যে ওঠানামা করে; এখানে গুরুত্বপূর্ণ অনুপাতটা — একটা ধ্রুবক গুণিতক পাল্টালেও ৩৩,৬৭০× পার্থক্যের মাত্রা (order of magnitude) পাল্টাবে না।)

নিজে বাড়ান:

1. status_polls বাড়িয়ে/কমিয়ে দেখুন — বাস্তব ATA controller-এ polling loop-এর দৈর্ঘ্য ডিভাইসের গতির উপর নির্ভর করে; এটা মোট overhead-এ কতটা প্রভাব ফেলে?
2. sectors_per_batch (virtio-র batch size) ১ থেকে ৫১২ পর্যন্ত বদলে একটা গ্রাফ কল্পনা করুন — batch size বাড়ানোর diminishing return কোথায় শুরু হয়?
3. একটা তৃতীয় মডেল যোগ করুন — modern AHCI (native command queuing, PIO-র চেয়ে ভালো কিন্তু virtio-র চেয়ে খারাপ) কত exit/sector হতে পারে, ধরে নেওয়া অনুমানসহ যুক্তি দিন।