সরাসরি পর্বে যান
পর্ব ৬০ · ৮৬-এর মধ্যে · মডিউল ১০

বাস্তব virtual machine — CPython bytecode আর JVM

Real Virtual Machines — CPython Bytecode and the JVM

Taught in Bangla, this lesson compares the Haat VM with two production stack machines. It reads CPython 3.14 code objects and frames with dis, shows PEP 659 adaptive specialization rewriting BINARY_OP on the second call, and inspects a JVM class file, its constant pool and javap output from real javac runs. A tampered class file is rejected by the JVM verifier with VerifyError, while the Haat VM, which has no verifier, crashes or gives wrong answers. It also surveys VMs such as Lua, BEAM and WebAssembly.

এই পর্বে যা শিখবেন

  • CPython 3.14-এর code object আর frame পড়া: byte offset, CACHE, superinstruction, আপেক্ষিক jump আর co_stacksize
  • Specializing adaptive interpreter (PEP 659) কীভাবে warm-up-এর পরে নির্দেশ বদলায়, আর অনুমান ভাঙলে কীভাবে ফেরে, সত্যিকারের counter দেখে
  • JVM-এর class file, constant pool আর javap -c -v-এর আউটপুট পড়া, typed নির্দেশ আর long-এর দুই ঘর
  • Bytecode verifier কেন দরকার, StackMapTable কী, আর Haat VM-এর জন্য একটি ছোট verifier লেখা
  • Haat VM-এর সঙ্গে তিন দিকের তুলনা, আর Lua, BEAM, .NET CLR ও WebAssembly-র জায়গা

১ · খেলনা VM থেকে আসল VM — কী একই, কী বাড়তি

পাড়ার দর্জি একটি খাতায় মাপ লেখেন, কাপড় কাটেন, সেলাই করেন। গাজীপুরের একটি garments কারখানাও ঠিক এই তিন কাজই করে। পার্থক্য অন্য জায়গায়: কারখানার গেটে QC পরিদর্শক কাঁচামাল আর কাটা টুকরো মেপে দেখেন, রোজ একই ধরনের কাজের জন্য আলাদা বিশেষ মেশিন বসানো থাকে, আর হিসাবের খাতা এমনভাবে বাঁধানো যে অন্য কারখানাও পড়তে পারে। Haat-এর VM সেই দর্জি; CPython আর JVM কারখানা। কাজের ধারণা এক, কিন্তু কারখানায় পরিদর্শন, বিশেষ মেশিন আর মানসম্মত খাতা যোগ হয়েছে।

পর্ব ৫৮ (Bytecode নকশা) আর পর্ব ৫৯ (Stack-based virtual machine)-এ Haat-এর নিজের bytecode আর virtual machine তৈরি হয়েছে: reference-এর compiler.py প্রতিটি function-কে একটি Code object বানায়, আর vm.py-র একটি loop সেগুলো একটি একটি নির্দেশ করে চালায়। এই পর্বে আমরা দুটি বাস্তব VM খুলে দেখব, যারা প্রতিদিন কোটি কোটি program চালায়: Python-এর প্রধান বাস্তবায়ন CPython আর Java-র JVM. লক্ষ্য দুটি: দেখা যে Haat-এ যা শিখেছেন তা সত্যিই সেখানে আছে, আর বোঝা যে বাস্তব VM কোন কোন সমস্যার জন্য বাড়তি কী রাখে।

পর্ব ০৪-এ (অনুবাদক) এক নজরে দেখেছিলেন, CPython আগে bytecode বানায় তারপর চালায়, আর Java-র javac class ফাইল লেখে যা JVM চালায়। এখানে আমরা এক স্তর নিচে নামব: frame-এর ভেতরে কী থাকে, ফাইলে নির্দেশ কীভাবে লেখা, আর চলার সময় নির্দেশ কীভাবে বদলায়। দুই ভাষার ব্যবহারকারীর দিক থেকে গল্পটি আছে Python কোর্সের পর্ব ০৫-এ (Python কীভাবে চলে) আর Java কোর্সের পর্ব ০৫-এ (Java কীভাবে চলে); এখানে সেগুলোর পুনরাবৃত্তি নয়, compiler-লেখকের চোখে তুলনা।

যেকোনো bytecode VM-কে পাঁচটি প্রশ্নের উত্তর দিতে হয়, আর তিনটি VM-এর উত্তর পাশাপাশি রাখলেই মিল আর অমিল পরিষ্কার হয়:

প্রশ্নHaat VMCPython 3.14JVM (Java 21)
কোডের একক কী?Code (প্রতি function একটি)code objectclass ফাইলের ভেতরে method-এর Code attribute
নির্দেশ কীভাবে লেখা?Python-এর (opcode, arg) tuple২ byte-এর একক, পেছনে CACHE ঘর১ byte opcode, পেছনে ০–৪ byte operand
ধ্রুবক কোথায়?consts তালিকা, প্রতি functionco_consts, প্রতি code objectএকটি constant pool, পুরো class-এর
মান কোথায় রাখে?frame-এর slots + একটি ভাগের stackframe-এর একটানা array: আগে local, পরে stackframe-এ local array আর আলাদা operand stack
Bytecode কি যাচাই হয়?না, compiler-কে বিশ্বাস করেনা, নিজের compiler-কে বিশ্বাস করেহ্যাঁ, চালানোর আগে verifier

টেবিলের প্রতিটি ঘর এই পর্বে সত্যিকারের run দিয়ে দেখব। চালানো হয়েছে লেখকের ল্যাবে CPython 3.14.4 (PSF License), আর Eclipse Temurin JDK 21.0.13 (GPLv2 + Classpath Exception; শুধু javac, javap আর java, কাজ শেষে মুছে ফেলা হয়েছে); পাতার ভেতরের Python ব্লক চলে আপনার browser-এর Pyodide-এ (CPython 3.14.2), আর Java ব্লক Wandbox-এ।

২ · CPython 3.14 — code object আর frame-এর ভেতরে

পরীক্ষার জন্য বাজারঘরের price function-কে Python-এ হুবহু লিখি। একটিই পার্থক্য: Haat-এর / শূন্যের দিকে কাটে, Python-এর // নিচের দিকে (floor); ধনাত্মক সংখ্যায় দুটির ফল এক, তাই এখানে চলবে। নিচের ব্লক CPython-এর code object-এর মাপজোখ ছাপে, তারপর প্রতিটি source লাইনের নিচে বাঁয়ে Haat reference-এর dis আর ডানে CPython-এর dis পাশাপাশি রাখে।

import dis, sys
src = """def price(qty, unit):
    p = qty * unit
    if p >= 1000:
        return p - p // 10
    return p
"""
ns = {}
exec(compile(src, "bazar.py", "exec"), ns)
c = ns["price"].__code__
ins = list(dis.get_instructions(c))
print("Python", sys.version.split()[0])
print("CPython code: args", c.co_argcount, "| locals", c.co_varnames,
      "| consts", c.co_consts, "| max stack", c.co_stacksize)
print("  ", len(ins), "instructions in", len(c.co_code), "bytes")
# `python -B haat.py dis bazar.haat`-এর price অংশ (reference-এর আসল আউটপুট)
haat = {2: ["LOAD_LOCAL 0", "LOAD_LOCAL 1", "MUL", "STORE_LOCAL 2"],
        3: ["LOAD_LOCAL 2", "CONST 0", "GE", "JUMP_IF_FALSE 14"],
        4: ["LOAD_LOCAL 2", "LOAD_LOCAL 2", "CONST 1", "DIV", "SUB", "RETURN"],
        5: ["LOAD_LOCAL 2", "RETURN"]}
print("Haat Code:    arity 2 | nlocals 3 | consts [1000, 10] | 16 instructions")
for line in (2, 3, 4, 5):
    print(f"-- line {line}: {src.splitlines()[line - 1].strip()}")
    cp = [f"{i.offset:>2} {i.opname} {i.argrepr or (i.arg if i.arg is not None else '')}".rstrip()
          for i in ins if i.positions.lineno == line]
    hp = haat[line]
    for k in range(max(len(cp), len(hp))):
        h = hp[k] if k < len(hp) else ""
        print(f"   {h:<17}| {cp[k] if k < len(cp) else ''}".rstrip())

আসল আউটপুট (ব্রাউজারের Python):

Python 3.14.2
CPython code: args 2 | locals ('qty', 'unit', 'p') | consts (1000,) | max stack 3
   16 instructions in 66 bytes
Haat Code:    arity 2 | nlocals 3 | consts [1000, 10] | 16 instructions
-- line 2: p = qty * unit
   LOAD_LOCAL 0     |  2 LOAD_FAST_BORROW_LOAD_FAST_BORROW qty, unit
   LOAD_LOCAL 1     |  4 BINARY_OP *
   MUL              | 16 STORE_FAST p
   STORE_LOCAL 2    |
-- line 3: if p >= 1000:
   LOAD_LOCAL 2     | 18 LOAD_FAST_BORROW p
   CONST 0          | 20 LOAD_CONST 1000
   GE               | 22 COMPARE_OP bool(>=)
   JUMP_IF_FALSE 14 | 26 POP_JUMP_IF_FALSE to L1
                    | 30 NOT_TAKEN
-- line 4: return p - p // 10
   LOAD_LOCAL 2     | 32 LOAD_FAST_BORROW_LOAD_FAST_BORROW p, p
   LOAD_LOCAL 2     | 34 LOAD_SMALL_INT 10
   CONST 1          | 36 BINARY_OP //
   DIV              | 48 BINARY_OP -
   SUB              | 60 RETURN_VALUE
   RETURN           |
-- line 5: return p
   LOAD_LOCAL 2     | 62 LOAD_FAST_BORROW p
   RETURN           | 64 RETURN_VALUE

প্রথমে মিলগুলো দেখুন। দুটিতেই ৩টি local ঘর (qty, unit, p), parameter আগে; দুটিতেই ১৬টি নির্দেশ (CPython-এর প্রথম RESUME লাইন ১-এ, তাই তালিকায় নেই); দুটিতেই post-order: আগে দুই operand, তারপর operator. if দুটিতেই “শর্ত মিথ্যা হলে লাফ”, আর return দুটিতেই stack-এর ওপরের মান নিয়ে ফেরে।

এবার অমিল। Encoding-এর পার্থক্য পর্ব ৫৮-এর (Bytecode নকশা) অংশ ৮-এর টেবিলে দেখেছেন: ২ byte-এর একক, ছোট int নির্দেশের ভেতরে (LOAD_SMALL_INT 10, তাই co_consts-এ শুধু 1000), আর দুটি load জোড়া একটি superinstruction. এখানে চলার দিকের তিনটি জিনিস দেখুন। (১) বাঁয়ের সংখ্যা byte offset: 2, 4, তারপর সরাসরি 16. BINARY_OP-এর পেছনে ১০ byte ফাঁকা CACHE ঘর; ৬৬ byte-এর মধ্যে ৩২ byte নির্দেশ, ৩৪ byte CACHE, যার কাজ অংশ ৩-এ। (২) Jump-এর লক্ষ্য L1 একটি লেবেল, আর ভেতরে সংখ্যাটি আপেক্ষিক (পরের stepper). (৩) NOT_TAKEN নিজে কিছু করে না। কেউ শাখা দেখতে চাইলে (sys.monitoring-এর branch event) CPython এটিকে আর আগের jump-কে INSTRUMENTED_ রূপে বদলে দেয়: ল্যাবে চালু করতেই নাম হলো INSTRUMENTED_POP_JUMP_IF_FALSE আর INSTRUMENTED_NOT_TAKEN, বন্ধ করতেই আগের রূপ। ল্যাবের CPython 3.14.4-এও ওপরের তালিকা হুবহু একই এসেছে।

Code object শুধু তালিকা; চালাতে লাগে একটি frame. CPython 3.11 থেকে প্রতিটি Python ডাকের জন্য ভেতরে একটি ছোট C struct (_PyInterpreterFrame) তৈরি হয়, যার শেষে একটানা একটি array থাকে: প্রথমে local-এর ঘর, তারপর ঠিক co_stacksizeটি stack-এর ঘর। Compiler আগেই হিসাব করে রেখেছে stack কত গভীর হবে (এখানে 3), তাই ডাকের সময় একবারে পুরো জায়গা নেওয়া যায়; চলার সময় stack বাড়ানোর পরীক্ষা লাগে না। (এই struct CPython-এর ভেতরের বিষয়, version-ভেদে বদলায়; Python থেকে যে frame object দেখেন, তা দরকার হলে এর ওপর বানানো হয়।) নিচের stepper-এ price(2, 520)-এর frame দেখুন: প্রতিটি সারি একটি নির্দেশ, ডানে সেই array.

0RESUME 02LOAD_FAST_BORROW_LOAD_FAST_BORROW 14BINARY_OP 5 (*)16STORE_FAST 2 (p)18LOAD_FAST_BORROW 2 (p)20LOAD_CONST 0 (1000)22COMPARE_OP 188 (bool(>=))26POP_JUMP_IF_FALSE 1630NOT_TAKEN32LOAD_FAST_BORROW_LOAD_FAST_BORROW 3434LOAD_SMALL_INT 1036BINARY_OP 2 (//)48BINARY_OP 10 (-)60RETURN_VALUE
price-এর frame
পরের নির্দেশ
local: qty│unit│p
stack (৩ ঘর)
  1. Frame তৈরি. Argument দুটি সরাসরি local ঘর ০ আর ১-এ বসেছে; p-এর ঘর ফাঁকা, stack-এর ৩টি ঘরও। RESUME ঢোকার মুখে একটি পরীক্ষা করে (যেমন অন্য thread বা signal-এর জন্য থামতে হবে কি না), stack ছোঁয় না।
  2. এক নির্দেশে দুই load. Argument 1 = binary 0000 0001: ওপরের চার bit ঘর ০ (qty), নিচের চার bit ঘর ১ (unit). Stack: [2, 520]. Haat-এ এই কাজে দুটি LOAD_LOCAL লাগে।
  3. গুণ, তারপর CACHE লাফিয়ে. BINARY_OP 5 দুটি মান নামিয়ে 1040 তোলে। নির্দেশটি নিজে ২ byte, কিন্তু পেছনে ৫টি CACHE একক (১০ byte) আছে, তাই পরের নির্দেশ offset 16-এ। Evaluation loop CACHE-কে কখনো নির্দেশ হিসেবে চালায় না।
  4. রাখা. STORE_FAST 2: 1040 যায় local ঘর ২-এ (p), stack খালি। Haat-এর STORE_LOCAL 2-এর হুবহু কাজ।
  5. তুলনার প্রস্তুতি. p আর ধ্রুবক 1000 (co_consts[0]) stack-এ: [1040, 1000].
  6. তুলনা. COMPARE_OP 188: argument-এ লেখা কোন তুলনা (>=) আর ফলকে bool বানাতে হবে কি না; dis সেটিই পড়ে দেখায় bool(>=). Stack: [True]. পেছনে ১টি CACHE, তাই পরেরটি 26-এ।
  7. শাখা. POP_JUMP_IF_FALSE 16 True নামায়; মিথ্যা নয়, তাই লাফ নেই। লাফ হলে লক্ষ্য হতো আপেক্ষিক: নির্দেশ আর তার CACHE-এর পরের offset 30 থেকে 16টি ২-byte একক, মানে 30 + 32 = 62, যেখানে L1. Haat-এ একই কাজ JUMP_IF_FALSE 14, পরম নির্দেশ-নম্বর।
  8. সবচেয়ে গভীর মুহূর্ত. Argument 34 = 0010 0010: দুবার ঘর ২, অর্থাৎ p, p. তারপর LOAD_SMALL_INT 10. Stack: [1040, 1040, 10], তিনটি ঘরই ভরা: ঠিক co_stacksize = 3.
  9. ভাগ আর বিয়োগ. BINARY_OP 2 (//) দেয় 104: [1040, 104]; BINARY_OP 10 (-) দেয় 936: [936]. দুটির পেছনেই ৫টি করে CACHE, তাই offset 36 → 48 → 60.
  10. ফেরত. RETURN_VALUE 936 নামিয়ে ডাকা frame-এর stack-এ দেয়, আর এই frame-এর জায়গা ছেড়ে দেয়। RESUME-সহ ১৪টি নির্দেশ চলেছে (offset 62-র দুটি চলেনি), Haat VM-এ একই ডাকে ১৪টিই।

এই ছবিতে Haat-এর সঙ্গে একটি সূক্ষ্ম পার্থক্যও আছে, যা পরে SVG-তে দেখবেন: Haat VM-এ সব call একটিই Python list-কে operand stack হিসেবে ভাগ করে (README: “one operand stack shared by all calls”), আর প্রতিটি Frame-এ শুধু slots. CPython প্রতিটি frame-কে নিজের মাপা stack দেয়, local-এর ঠিক পরে। Call-এর ধাপ, frame আর activation record-এর সাধারণ ধারণা পর্ব ৩০-এ (Subprogram-এর বাস্তবায়ন).

৩ · চলতে চলতে নিজেকে বদলানো bytecode — PEP 659

Haat-এর ADD প্রতিবার দেখে দুটি মান Int না Str. CPython-এর BINARY_OP-এর কাজ আরও ভারী: দুটি object-এর type দেখে সঠিক যোগ বা গুণের নিয়ম খুঁজতে হয়, কারণ Python-এ * int, float, str, list বা আপনার নিজের class-এর ওপরও চলে। অথচ বাস্তবে একটি নির্দিষ্ট জায়গার গুণ প্রায় সবসময় একই type পায়। Python 3.11 (২০২২) থেকে CPython এই পর্যবেক্ষণকে কাজে লাগায়: PEP 659-এর specializing adaptive interpreter, মূল নকশা Mark Shannon-এর। ধারণাটির নাম quickening: চলার সময় একটি সাধারণ নির্দেশকে তার জায়গাতেই একটি বিশেষ, দ্রুত নির্দেশ দিয়ে বদলে দেওয়া। Python-এর দিক থেকে মূল ধারণাটি Python কোর্সের পর্ব ০৫-এ আছে; এখানে counter ধরে ধরে যন্ত্রটি খুলব।

প্রথমে লেখকের ল্যাবের সত্যিকারের run (CPython 3.14.4): price-কে int দিয়ে ১০০০ বার ডাকার পরে dis.dis(price, adaptive=True):

  4          0       RESUME_CHECK             0
  5          2       LOAD_FAST_BORROW_LOAD_FAST_BORROW 1 (qty, unit)
             4       BINARY_OP_MULTIPLY_INT   5 (*)
            16       STORE_FAST               2 (p)
  6         18       LOAD_FAST_BORROW         2 (p)
            20       LOAD_CONST_MORTAL        0 (1000)
            22       COMPARE_OP_INT         188 (bool(>=))
            26       POP_JUMP_IF_FALSE       16 (to L1)
            30       NOT_TAKEN
  7         32       LOAD_FAST_BORROW_LOAD_FAST_BORROW 34 (p, p)
            34       LOAD_SMALL_INT          10
            36       BINARY_OP                2 (//)
            48       BINARY_OP_SUBTRACT_INT  10 (-)
            60       RETURN_VALUE

(ফাঁকা লাইন বাদ।) পাঁচটি নির্দেশ বদলেছে, কিন্তু offset একটিও নড়েনি: বদল হয় জায়গায়, তাই jump-এর হিসাব ঠিক থাকে। BINARY_OP_MULTIPLY_INT শুধু দেখে দুটিই int কি না, হলে সরাসরি গুণ করে; এই ছোট পরীক্ষাকে বলে guard. // বদলায়নি: CPython 3.14.4-এ ১৭টি পরিবারের ৮৪টি বিশেষ নির্দেশ আছে (dis._specializations), কিন্তু int-এর floor division-এর জন্য কোনোটি নেই। আর LOAD_CONST_MORTAL বলছে 1000 এমন object যার reference গুনতে হয় (-5 থেকে 256 পর্যন্ত ছোট int CPython-এ “অমর”, তাদের জন্য আছে LOAD_CONST_IMMORTAL).

কখন বদলায়? প্রতিটি বদলযোগ্য নির্দেশের প্রথম CACHE ঘরে একটি counter থাকে। dis-এর cache_info থেকে সেটি পড়া যায়; নিচে ওপরের ১২ bit (raw >> 4) দেখাচ্ছি, যেটি আসল গোনার মান, নিচের ৪ bit পিছিয়ে যাওয়ার (backoff) ধাপ। Block-টি নতুন code object বানায়, যাতে আগের warm-up না থাকে:

import dis
src = """def price(qty, unit):
    p = qty * unit
    if p >= 1000:
        return p - p // 10
    return p
"""
ns = {}
exec(compile(src, "bazar.py", "exec"), ns)   # নতুন code object, কোনো warm-up নেই
price = ns["price"]

def look():                    # অফসেট 4, 22, 36, 48-এর নির্দেশ আর তার counter
    out = []
    for i in dis.get_instructions(price, adaptive=True):
        if i.offset in (4, 22, 36, 48):
            raw = int.from_bytes(i.cache_info[0][2], "little")
            out.append(f"{i.opname}[{raw >> 4}]")
    return "  ".join(out)

print("শুরু   :", look())
for n in range(1, 4):
    price(2, 520)
    print(f"Int  {n:>2}:", look())
for n in range(1, 54):
    price(2.5, 520.0)
    if n in (1, 2, 52, 53):
        print(f"float{n:>2}:", look())
print(price(2, 520), price(2.5, 520.0))

আসল আউটপুট (ব্রাউজারের Python):

শুরু   : BINARY_OP[1]  COMPARE_OP[1]  BINARY_OP[1]  BINARY_OP[1]
Int   1: BINARY_OP[0]  COMPARE_OP[0]  BINARY_OP[0]  BINARY_OP[0]
Int   2: BINARY_OP_MULTIPLY_INT[52]  COMPARE_OP_INT[52]  BINARY_OP[2]  BINARY_OP_SUBTRACT_INT[52]
Int   3: BINARY_OP_MULTIPLY_INT[52]  COMPARE_OP_INT[52]  BINARY_OP[1]  BINARY_OP_SUBTRACT_INT[52]
float 1: BINARY_OP_MULTIPLY_INT[51]  COMPARE_OP_INT[51]  BINARY_OP[0]  BINARY_OP_SUBTRACT_INT[51]
float 2: BINARY_OP_MULTIPLY_INT[50]  COMPARE_OP_INT[50]  BINARY_OP[6]  BINARY_OP_SUBTRACT_INT[50]
float52: BINARY_OP_MULTIPLY_INT[0]  COMPARE_OP_INT[0]  BINARY_OP[2]  BINARY_OP_SUBTRACT_INT[0]
float53: BINARY_OP_MULTIPLY_FLOAT[52]  COMPARE_OP[0]  BINARY_OP[1]  BINARY_OP_SUBTRACT_FLOAT[52]
936 1170.0

পুরো জীবনচক্র এক জায়গায়। নতুন code object-এ counter 1; প্রথম ডাকে কমে 0; দ্বিতীয় ডাকে 0 দেখে নির্দেশটি দেখা type অনুযায়ী বদলে যায় আর counter বসে 52. এরপর float এলে guard ব্যর্থ হয়: সেবার সাধারণ পথে কাজ হয় (ফল সঠিক), আর counter এক কমে। ৫২টি ব্যর্থতার পরে counter 0, আর ৫৩তম ডাকে নির্দেশটি নতুন type দেখে আবার বদলায়: BINARY_OP_MULTIPLY_FLOAT. তুলনাটি সাধারণ COMPARE_OP-এ ফিরেছে, কারণ এখন একপাশে float (1300.0) আর অন্যপাশে int (1000); দুটি float বা দুটি int-এর বিশেষ রূপ আছে, মিশ্রণের নেই। //-এর counter-এর 2, 1, 0, 6 লাফ backoff: বিশেষ রূপ বানাতে ব্যর্থ হলে CPython ক্রমশ বেশি দেরি করে আবার চেষ্টা করে। ল্যাবের CPython 3.14.4-এও এই সংখ্যাগুলো হুবহু এসেছে; অন্য version-এ সীমা আর নাম বদলাতে পারে।

এবার ধাপে ধাপে, ব্লকের প্রতিটি লাইন একটি ধাপ:

0RESUME4BINARY_OP (*)20LOAD_CONST (1000)22COMPARE_OP (>=)36BINARY_OP (//)48BINARY_OP (-)
dis(adaptive=True) [counter]
4
22
36
48
  1. শুরু. compile() সবে code object বানিয়েছে। চারটি নির্দেশই সাধারণ রূপে, প্রতিটির counter 1. এখনো কিছু চলেনি।
  2. প্রথম ডাক. ঢোকার মুখে RESUME হয় RESUME_CHECK, আর LOAD_CONST হয় LOAD_CONST_MORTAL (এগুলো type দেখে না, প্রথমবারেই বদলায়)। চারটি counter 1 থেকে 0.
  3. দ্বিতীয় ডাক: specialization. Counter 0, তাই প্রতিটি নির্দেশ চলার মুখে দেখে আসলে কী এসেছে: দুটি int. গুণ, তুলনা আর বিয়োগ বিশেষ রূপ পায়, counter 52. //-এর কোনো বিশেষ রূপ নেই, তাই সে সাধারণ থাকে আর counter 2-তে পিছিয়ে যায় (backoff).
  4. তৃতীয় ডাক. Guard সফল (আবার int), তাই counter নড়ে না: 52-তেই থাকে। শুধু //-এর পিছিয়ে-থাকা counter 2 থেকে 1.
  5. প্রথম float. BINARY_OP_MULTIPLY_INT-এর guard দেখে 2.5 int নয়: সেবার সাধারণ পথে গুণ হয়, ফল ঠিক 1170.0. Counter 52 থেকে 51. একে CPython-এর ভাষায় একটি “deopt”: বিশেষ পথ ছেড়ে সাধারণ পথে যাওয়া, কোনো machine code ফেলে দেওয়া নয়।
  6. ৫২তম float. প্রতিবার guard ব্যর্থ, প্রতিবার counter এক কম: এখন 0. নির্দেশের নাম তখনো ..._INT, ফল তবু সবসময় ঠিক।
  7. ৫৩তম float: আবার বদল. Counter 0, তাই নির্দেশ নতুন type দেখে BINARY_OP_MULTIPLY_FLOAT আর BINARY_OP_SUBTRACT_FLOAT হয়, counter আবার 52. তুলনা পায় float আর int-এর মিশ্রণ, যার বিশেষ রূপ নেই, তাই সাধারণ COMPARE_OP-এ ফেরে। পুরো সময়ে ফল একবারও বদলায়নি: 936 আর 1170.0.

তিনটি জিনিস মনে রাখার মতো। প্রথমত, এটি JIT নয়: কোনো machine code তৈরি হয় না, শুধু bytecode-এর এক নির্দেশ আরেক নির্দেশে বদলায়, আর প্রতিটি বিশেষ নির্দেশ interpreter-এর ভেতরে আগে থেকেই C-তে লেখা। দ্বিতীয়ত, CACHE ঘরগুলো একধরনের inline cache: যেমন attribute পড়ার বিশেষ রূপ সেখানে type-এর version আর খুঁজে পাওয়া জায়গা রাখে, যাতে পরের বার খুঁজতে না হয় (ধারণাটি পর্ব ১২-এ, Scripting আর dynamic ভাষা). তৃতীয়ত, বদলটি code object-এর ভেতরেই হয়, তাই একই code থেকে তৈরি সব function object (যেমন একটি function-এর ভেতরে বারবার def করা) একই warm-up ভাগ করে। CPython 3.13 থেকে এর ওপর একটি পরীক্ষামূলক JIT-ও আছে, 3.14-এও পরীক্ষামূলক আর ডিফল্টে বন্ধ; JIT, tier আর deoptimization-এর পুরো গল্প পর্ব ৬১-এ (JIT compilation — profiling, tracing আর deoptimization).

Haat-এর এটি দরকার কি? খুব কম। Haat statically typed: type checker আগেই জানে প্রতিটি + Int-এর না Str-এর। তাই compiler চাইলে আগেই ADD_INT আর ADD_STR আলাদা করে লিখতে পারত, ঠিক যেমন JVM-এ iadd, ladd, fadd আলাদা। CPython-কে চলার সময় অনুমান করতে হয়, কারণ Python-এর compiler type জানে না। Static typing যে কাজ compile time-এ একবার করে, dynamic ভাষার VM সেটি run time-এ বারবার শেখে।

৪ · JVM — class file, constant pool আর javap

এবার একই বাজারঘরের program Java 21-এ। Haat-এর Int 64-বিট, wrap করে (decision 13), তাই Java-তে long নিলাম: Java-র long-ও 64-বিট two's complement, overflow-এ wrap করে, আর / শূন্যের দিকে কাটে। অর্থাৎ ভাষা হিসেবে Haat-এর সবচেয়ে কাছের আত্মীয় এটিই। main-এ bazar.haat-এর বাকি অংশ হুবহু; java Bazar ছাপে 996, 5000, 3, Haat reference-এর মতোই। সত্যিকারের run, ল্যাবে Temurin 21.0.13:

$ javac -version
javac 21.0.13
$ javac Bazar.java && java Bazar
996
5000
3
$ javap -c -v Bazar.class          # কিছু অংশ, ফাইলের পথ বাদ
  Compiled from "Bazar.java"
public class Bazar
  minor version: 0
  major version: 65
Constant pool:
   #7 = Long               1000l
   #9 = Long               10l
  #11 = Long               60l
  #17 = Methodref          #18.#19        // Bazar.price:(JJ)J
  #19 = NameAndType        #21:#22        // price:(JJ)J
  #21 = Utf8               price
  #22 = Utf8               (JJ)J
  ...
  static long price(long, long);
    descriptor: (JJ)J
    flags: (0x0008) ACC_STATIC
    Code:
      stack=6, locals=6, args_size=2
         0: lload_0
         1: lload_2
         2: lmul
         3: lstore        4
         5: lload         4
         7: ldc2_w        #7                  // long 1000l
        10: lcmp
        11: iflt          24
        14: lload         4
        16: lload         4
        18: ldc2_w        #9                  // long 10l
        21: ldiv
        22: lsub
        23: lreturn
        24: lload         4
        26: lreturn
      StackMapTable: number_of_entries = 1
        frame_type = 252 /* append */
          offset_delta = 24
          locals = [ long ]

এখানে পড়ার মতো অনেক কিছু। javap হলো JDK-র নিজের disassembler; -c নির্দেশ দেখায়, -v বাকি সব।

  • Class file-এর মাথা. major version: 65 মানে Java 21-এর ফরম্যাট; পুরোনো JVM এই ফাইল চালাতে রাজি হবে না। ফাইলের প্রথম চার byte CA FE BA BE (ল্যাবে নিজে পড়ে দেখা), যে কারণে Java-র জগতে এই সংখ্যাটি এত পরিচিত।
  • Constant pool. Haat-এ প্রতিটি function-এর নিজের consts; JVM-এ পুরো class-এর একটিই তালিকা, যেখানে সংখ্যা ছাড়াও আছে method-এর নাম, type-এর লেখা আর অন্য class-এর উল্লেখ। নির্দেশ শুধু নম্বর দেয়: ldc2_w #7 মানে “pool-এর ৭ নম্বর জিনিস”. #7-এর পরে #9, কারণ একটি long pool-এর দুটি ঘর নেয় (JVM specification নিজেই এই সিদ্ধান্তকে পেছন ফিরে “poor choice” বলেছে)।
  • Descriptor. (JJ)J মানে দুটি long নেয়, একটি long ফেরত দেয় (J = long; সম্ভবত L আগেই class-এর জন্য নেওয়া ছিল বলে)। একে বলে method descriptor; invokestatic #17 এর মাধ্যমে নাম আর type দুটি মিলিয়ে ঠিক method খোঁজে। Haat VM-এ CALL 2 শুধু argument গোনে, type compile time-এই যাচাই হয়ে গেছে।
  • Typed নির্দেশ. lload, lmul, ldiv, lreturn: শুরুর l মানে long. int হলে হতো iload, imul. JVM-এর প্রায় ২০০টি opcode-এর বড় অংশ এভাবে type অনুযায়ী ভাগ করা। Haat-এর একটি ADD Int আর Str দুটিই সামলায়; JVM-এ type নির্দেশের নামেই।
  • উল্টো শর্ত. p >= 1000 হয়েছে lcmp (ফল -1, 0 বা 1) আর iflt 24: “ছোট হলে লাফ”, মানে শর্ত মিথ্যা হলে লাফ, ঠিক Haat-এর JUMP_IF_FALSE-এর মতো চিন্তা। 24 javap-এর দেখানো পরম offset; ফাইলে লেখা থাকে আপেক্ষিক +13 (24 − 11).
  • stack=6, locals=6. long দুটি ঘর নেয়: qty ঘর ০–১, unit ২–৩, p ৪–৫. Stack-এ সবচেয়ে বেশি তিনটি long, তাই ৬. CPython-এর co_stacksize-এর মতোই, javac এটি আগে হিসাব করে ফাইলে লিখে দেয়।

নিচের stepper-এ একই price(2, 520), এবার JVM-এর frame-এ। লক্ষ করুন, এখানে local আর stack দুটি আলাদা জায়গা, আর প্রতিটি long দুটি ঘর।

0lload_01lload_22lmul3lstore 45lload 47ldc2_w #7 // 100010lcmp11iflt 2414lload 416lload 418ldc2_w #9 // 1021ldiv22lsub23lreturn24lload 426lreturn
price-এর frame (locals=6, stack=6)
local ০–১ │ ২–৩ │ ৪–৫
operand stack
ঘর ভরা
  1. lload_0. Local ঘর ০–১-এর long qty = 2 stack-এ। একটি long, কিন্তু stack-এর দুটি ঘর ভরে।
  2. lload_2. unit = 520, যা আছে ঘর ২–৩-এ (ঘর ১ নয়!)। Stack: [2, 520], ৪টি ঘর।
  3. lmul. দুটি long নামিয়ে গুণ: [1040]. নির্দেশ নিজেই জানে দুটি long; চলার সময় type দেখার কিছু নেই।
  4. lstore 4. 1040 যায় p-এর ঘর ৪–৫-এ। Stack খালি।
  5. lload 4, ldc2_w #7. p আর constant pool-এর #7 (long 1000) stack-এ: [1040, 1000].
  6. lcmp. দুটি long তুলনা করে একটি int তোলে: বড় হলে 1, সমান হলে 0, ছোট হলে -1. এখানে 1040 > 1000, তাই [1], মাত্র এক ঘর।
  7. iflt 24. int নামিয়ে দেখে 0-এর ছোট কি না। 1 ছোট নয়, তাই লাফ নেই, offset 14-এ চলে। Haat-এর GE + JUMP_IF_FALSE-এর কাজ এখানে lcmp + iflt.
  8. সবচেয়ে গভীর. p, p আর pool-এর #9 (long 10): [1040, 1040, 10], ছয়টি ঘরই ভরা। ঠিক এই কারণেই javap বলেছে stack=6.
  9. ldiv, lsub. 1040 / 10 = 104 (Java-র long ভাগ শূন্যের দিকে কাটে, Haat-এর মতো), তারপর 1040 − 104 = 936.
  10. lreturn. 936 ডাকা method-এর stack-এ যায়, frame শেষ। চলেছে ১৪টি নির্দেশ, CPython-এ আর Haat-এ ঠিক ততগুলোই। ধারণা এক, লেখার ধরন আলাদা।

একটি class ফাইল নিছক byte-এর সারি, আর তার ফরম্যাট JVM specification-এ পুরোপুরি লেখা। তাই যেকোনো program তা পড়তে পারে। নিচের Java program নিজের Bazar.class খুলে মাথা আর constant pool-এর long ধ্রুবকগুলো ছাপে: একটি ছোট javap, Wandbox-এর সত্যিকারের JDK-তে চলে।

import java.io.DataInputStream;

class Bazar {
    static long price(long qty, long unit) {
        long p = qty * unit;
        if (p >= 1000) { return p - p / 10; }
        return p;
    }
    public static void main(String[] args) throws Exception {
        System.out.println("price(2, 520) = " + price(2, 520));
        // JVM যে class ফাইলটি চালাচ্ছে, সেটিই খুলে পড়া
        var in = new DataInputStream(Bazar.class.getResourceAsStream("Bazar.class"));
        int magic = in.readInt(), minor = in.readUnsignedShort(), major = in.readUnsignedShort();
        System.out.printf("magic %X, major %d, minor %d%n", magic, major, minor);
        int count = in.readUnsignedShort();
        System.out.println("constant pool count: " + count);
        for (int i = 1; i < count; i++) {
            int tag = in.readUnsignedByte();
            switch (tag) {
                case 1 -> in.readUTF();                        // Utf8
                case 3, 4 -> in.readInt();                     // Integer, Float
                case 5 -> System.out.println("  #" + i++ + " Long " + in.readLong());
                case 6 -> { in.readLong(); i++; }              // Double: দুটি ঘর
                case 7, 8, 16, 19, 20 -> in.readUnsignedShort();
                case 15 -> { in.readUnsignedByte(); in.readUnsignedShort(); }
                default -> in.readInt();                       // ref, NameAndType ...
            }
        }
    }
}

আসল আউটপুট (Wandbox):

price(2, 520) = 936
magic CAFEBABE, major 65, minor 0
constant pool count: 117
  #7 Long 1000
  #9 Long 10
  #17 Long 2
  #19 Long 520

JVM যে ফাইল চালাচ্ছে, তার প্রথম চার byte সত্যিই CAFEBABE, আর version 65 (Java 21). প্রতিটি Long দুটি নম্বর খেয়ে নেয়: #7-এর পরে #9, #17-এর পরে #19; loop-এ i++ সেই বাড়তি ঘর লাফায়। এখানে pool-এ ১১৬টি ঘর (count থেকে এক কম), ল্যাবের ছোট Bazar-এর ৪৯টির চেয়ে অনেক বেশি। কারণ "price(2, 520) = " + …: Java 9 থেকে javac string জোড়ার কাজ একটি invokedynamic নির্দেশে দেয়, যার জন্য pool-এ method handle আর bootstrap-এর তথ্য লাগে (case 15 আর default-এর ঘরগুলো)। একটি সাধারণ + class ফাইলে কত কিছু টেনে আনে, javap না খুললে বোঝা যায় না। (Wandbox-এর javac-এর version আলাদা হলে count একটু বদলাতে পারে।)

৫ · Verifier — JVM কেন bytecode-কে বিশ্বাস করে না

Haat VM, CPython আর JVM-এর সবচেয়ে বড় দর্শনগত পার্থক্য এখানে। Haat-এর vm.py ধরে নেয় তার হাতে আসা Code object reference-এর নিজের compiler বানিয়েছে, আর compiler-এর আগে type checker চলেছে। কেউ মাঝপথে bytecode বদলালে কী হয়? ল্যাবে bazar.haat compile করে price-এর একটি করে নির্দেশ হাতে বদলে vm.run চালানো হয়েছে (reference-এর ফাইল না ছুঁয়ে, শুধু মেমরিতে তৈরি Code object বদলে):

LOAD_LOCAL 1 -> LOAD_LOCAL 7   -> IndexError: list index out of range
LOAD_LOCAL 1 -> POP            -> IndexError: pop from empty list
LOAD_LOCAL 1 -> CONST 'ab'     -> TypeError: can only concatenate str (not "int") to str
JUMP_IF_FALSE 14 -> JUMP_IF_FALSE 99 -> ran, output ['996', '5000', '3']
LOAD_LOCAL 1 -> CONST 0        -> ran, output ['1800', '5000', '3']

প্রথম তিনটিতে Haat-এর নিজের কোনো error message নেই; ভেঙে পড়েছে নিচের স্তরের Python, তার নিজের ভাষায়। চতুর্থটি কিছুই টের পায়নি, কারণ price(2, 520)-এ শর্ত সত্য, লাফ কখনো হয় না: অন্য ইনপুটের জন্য একটি লুকোনো বোমা। পঞ্চমটি সবচেয়ে ভয়ের: কোনো error নেই, শুধু ভুল উত্তর। CONST 0 মানে 1000, তাই p = 2 × 1000 = 2000, আর 2000 − 200 = 1800. CPython-ও একই দর্শন মানে: সে ধরে নেয় bytecode তার নিজের compiler-এর তৈরি। ল্যাবে price-এর code object-এ প্রথম load-টিকে NOP বানিয়ে ডাকা হলে কোনো Python exception আসেনি: পুরো Python process নিজেই crash করেছে (Git Bash জানাল Segmentation fault, exit code 139). এজন্যই Python-এর documentation marshal (যে ফরম্যাটে .pyc লেখা) সম্পর্কে সাবধান করে: অবিশ্বস্ত উৎসের data কখনো unmarshal করবেন না। অচেনা উৎসের .pyc চালানো আর অচেনা machine code চালানো একই ঝুঁকি।

Java ভিন্ন পথ নিয়েছিল, কারণ ১৯৯৫ সালে তার বড় প্রতিশ্রুতি ছিল network থেকে নামানো অপরিচিত কোড (applet) নিরাপদে চালানো। তাই JVM চালানোর আগে প্রতিটি class ফাইলের প্রতিটি method পরীক্ষা করে: bytecode verifier. সে প্রমাণ করতে চায়, কোনো পথেই stack underflow বা overflow হবে না, প্রতিটি নির্দেশ ঠিক type-এর মান পাবে, আর কোনো jump নির্দেশের মাঝখানে বা কোডের বাইরে পড়বে না। ল্যাবে Bazar.class-এর ঠিক একটি byte বদলানো হয়েছে, lmul (0x69) থেকে imul (0x68). সত্যিকারের run:

$ java -cp bad Bazar
Error: Unable to initialize main class Bazar
Caused by: java.lang.VerifyError: Bad type on operand stack
Exception Details:
  Location:
    Bazar.price(JJ)J @2: imul
  Reason:
    Type long_2nd (current frame, stack[3]) is not assignable to integer
  Current Frame:
    bci: @2
    flags: { }
    locals: { long, long_2nd, long, long_2nd }
    stack: { long, long_2nd, long, long_2nd }

একটি লাইনও চলেনি, main-ও না। Verifier ঠিক জায়গা (@2: imul) আর কারণ বলেছে: stack-এ দুটি long (প্রতিটি দুই ঘর: long, long_2nd), অথচ imul চায় দুটি int. Verifier আসলে একটি ছোট abstract interpretation: আসল মানের বদলে প্রতিটি ঘরের শুধু type নিয়ে bytecode “চালায়”, আর যেখানে দুটি পথ মেলে (যেমন jump-এর লক্ষ্যে) সেখানে দুই পথের type মেলে কি না দেখে।

সেই মেলার জায়গাগুলোর জন্যই javap-এর আউটপুটে ছিল StackMapTable. javac নিজে লিখে দেয়: “offset 24-এ (return p;, jump-এর লক্ষ্য) local-এ একটি বাড়তি long আছে” (append, locals = [ long ]). ফলে verifier-কে কোনো loop-এর fixpoint খুঁজতে হয় না; সে শুধু এক pass-এ মিলিয়ে দেখে, দাবিগুলো সত্য কি না। এই “প্রমাণ সঙ্গে পাঠানো, যাচাই সস্তা রাখা” নকশা Java 6-এ এসেছে, আর Java 7-এর নতুন class ফাইলে বাধ্যতামূলক। WebAssembly-ও একই দর্শনে চলে: প্রতিটি module চালানোর আগে এক pass-এ validate হয়।

Verifier সব ভুল ধরে না। ল্যাবে আরেকটি byte বদলানো হয়েছে: lload_2 (unit) থেকে lconst_1 (ধ্রুবক 1). দুটিই একটি long তোলে, তাই verifier খুশি, আর java ছাপল 62, 5000, 3: price এখন qty × 1 = 2 দেয়, আর 2 + 60 = 62. Haat-এর CONST 0-এর 1800-এর মতোই। Verifier প্রমাণ করে কোড নিরাপদ (VM ভাঙবে না), সঠিক নয়। সঠিকতা আসে compiler-এর পরীক্ষা আর differential testing থেকে।

Haat-এর জন্য এর সবচেয়ে সরল রূপটি আপনি পর্ব ৫৮-এর (Bytecode নকশা) অংশ ৭-এ দেখেছেন: প্রতিটি opcode-এর stack effect দিয়ে সব পথ ধরে গভীরতা হিসাব, আর দুই পথ একই নির্দেশে ভিন্ন গভীরতায় এলে কোড বাতিল। ল্যাবে সেই ধরনের একটি checker (সঙ্গে “jump কোডের বাইরে কি না” পরীক্ষা) ওপরের তিনটি বদলানো price-এ (POP, JUMP_IF_FALSE 99, CONST 0) চালানো হলো: POP-এর বদলে বলল price @2 MUL: needs 2, stack has 0, JUMP_IF_FALSE 99-এর বদলে বলল jump to 99 is outside the code (যা VM-এ চালিয়ে ধরা পড়েনি, কারণ price(2, 520)-এ লাফ কখনো হয় না), আর CONST 0-এর বদল পাস করিয়ে দিল। Type-এর হিসাব না রাখায় এটি JVM-এর verifier-এর অর্ধেক; আর ওপরের বাক্সে দেখলেন, পুরো verifier-ও শেষ ধরনের ভুল ধরে না।

৬ · তিন VM পাশাপাশি — frame, জায়গা আর গোনা নির্দেশ

তিনটি VM price(2, 520)-এর সবচেয়ে গভীর মুহূর্তে (stack-এ 1040, 1040, 10) মেমরিতে কেমন দেখায়, নিচের ছবিতে:

ছবি ৬০.১ — একই মুহূর্ত, তিনটি frame

price(2, 520)-এ p - p / 10-এর ভাগের ঠিক আগে: local-এ qty, unit, p; stack-এ 1040, 1040, 10.

Frames of price(2, 520) in the Haat VM, CPython 3.14 and the JVM at the deepest stack point Haat VM — vm.py Frame(price): ip আর slots 25201040 qtyunitp একটিই operand stack, সব call-এর 1040104010 ← ওপর CPython 3.14 — frame localsplus: একটানা একটি array 252010401040104010 qtyunitp local (৩ ঘর)value stack (৩ ঘর) co_stacksize = 3: জায়গা ডাকের সময়ই ঠিক JVM — price-এর frame local variable array (max_locals = 6) 2·520·1040· qty (০–১)unit (২–৩)p (৪–৫) আলাদা operand stack (max_stack = 6) 1040·1040·10· হলুদ ঘর: long-এর দ্বিতীয় অর্ধেক
ছবি ৬০.১ — তিনটিতেই একই তিনটি local আর একই তিনটি stack-মান। পার্থক্য সাজানোয়: Haat সব call-এর জন্য একটি list ভাগ করে, CPython প্রতিটি frame-এ local-এর ঠিক পরে নিজের মাপা stack রাখে, JVM local আর stack আলাদা রাখে আর প্রতিটি long-কে দুই ঘর দেয়।

এবার পুরো program-এর হিসাব: bazar চলতে কতটি নির্দেশ লাগে? Haat VM-এর উত্তর পর্ব ৫৯-এর profiler দিয়েছে, আর ল্যাবে reference-এর vm.py-এর প্রতিটি fetch গুনেও (ফাইল না বদলে, instrs তালিকাকে একটি গোনা-list দিয়ে মুড়ে) একই সংখ্যা এসেছে: ১২০টি নির্দেশ চলেছে, compile হয়েছে মোট ৬৭টি। CPython-এর জন্য নিচের ব্লক sys.settrace-এর opcode-স্তরের trace দিয়ে একই কাজ করে, দুইভাবে: program top level-এ, আর পুরোটা একটি main()-এর ভেতরে।

import sys, dis
from collections import Counter
BODY = """def price(qty, unit):
    p = qty * unit
    if p >= 1000:
        return p - p // 10
    return p
def delivery(total):
    if total >= 1000:
        return 0
    else:
        return 60
first = price(2, 520) + delivery(price(2, 520))
print(first)
total = 0
rounds = 0
while total < 5000:
    total = total + 1250
    rounds = rounds + 1
print(total)
print(rounds - 1)
"""
def count(src):                          # প্রতিটি চলা নির্দেশ গোনা
    seen = Counter()
    def tracer(frame, event, arg):
        if frame.f_code.co_filename != "bazar.py": return None
        frame.f_trace_opcodes = True
        if event == "opcode":
            seen[dis.opname[frame.f_code.co_code[frame.f_lasti]]] += 1
        return tracer
    sys.settrace(tracer); exec(compile(src, "bazar.py", "exec"), {}); sys.settrace(None)
    return sum(seen.values()), [k for k, _ in seen.most_common(3)]
print("top level :", count(BODY))
inner = "def main():\n" + "".join("    " + l + "\n" for l in BODY.splitlines()) + "main()\n"
print("in main() :", count(inner))

আসল আউটপুট (ব্রাউজারের Python):

996
5000
3
top level : (136, ['LOAD_NAME', 'LOAD_CONST', 'BINARY_OP'])
996
5000
3
in main() : (142, ['LOAD_FAST_BORROW', 'LOAD_CONST', 'BINARY_OP'])

CPython চালিয়েছে ১৩৬টি নির্দেশ, Haat VM ১২০টি: একই মাপের হিসাব। আসল শিক্ষা সবচেয়ে বেশি চলা নির্দেশে। Top level-এ total, rounds সব module-এর নাম, আর LOAD_NAME প্রতিবার একটি dictionary-তে নাম খোঁজে। main()-এর ভেতরে একই নাম local, আর LOAD_FAST_BORROW শুধু একটি array-র ঘর পড়ে। Haat-এর compiler এই কাজ সবসময় আগেই সেরে রাখে: resolver প্রতিটি global-কে একটি নম্বর দেয়, তাই top level-এও LOAD_GLOBAL 3 একটি list-এর ঘর মাত্র (পর্ব ৫১-এর symbol table-এর ফল)। (ভেতরের সংস্করণে ৬টি বেশি: main নিজে বানানো, ডাকা আর তার থেকে ফেরার বাড়তি নির্দেশ। co_code সবসময় বদলানোর আগের bytecode দেয়, তাই নামগুলো সাধারণ রূপে; আর ঢোকার মুখের RESUME এই trace-এ opcode হিসেবে আসে না।)

নির্দেশের সংখ্যা কাছাকাছি হলেও সময় নয়। ল্যাবে একই যন্ত্রে, একই bazar ২০০০ বার চালিয়ে সেরা গড়: Haat VM ২৯ মাইক্রোসেকেন্ড, CPython ১.৩–১.৪ মাইক্রোসেকেন্ড, প্রায় ২০ গুণ পার্থক্য (একটি যন্ত্রের উদাহরণ মাত্র, benchmark নয়)। কারণ Haat VM নিজেই Python-এ লেখা: তার প্রতিটি নির্দেশ CPython-এর কয়েক ডজন নির্দেশ (একটি if-শৃঙ্খল, tuple খোলা, list-এ append). এটি “VM-এর ওপর VM”. CPython-এর evaluation loop C-তে লেখা, আর dispatch-এ threaded code-এর মতো কৌশল ব্যবহার করে (বিস্তারে পর্ব ৫৯-এর অংশ ৬). HotSpot-এর interpreter আরও এক ধাপ এগিয়ে: JVM চালু হওয়ার সময় প্রতিটি opcode-এর জন্য machine code-এর ছোট টুকরো বানিয়ে নেয় (template interpreter বলে পরিচিত), আর গরম method-কে JIT-এ পাঠায়।

পুরো তুলনা এক টেবিলে:

দিকHaat VMCPython 3.14JVM (Java 21)
Opcode-এর সংখ্যা৩১dis.opmap-এ ১৪৩টি নাম (২১টি INSTRUMENTED_ রূপসহ), আর ৮৪টি বিশেষ রূপপ্রায় ২০০
নির্দেশে typeনা (ADD Int বা Str)না, চলতে চলতে শেখেহ্যাঁ (iadd, ladd, …)
Jump-এর argumentপরম নির্দেশ-নম্বরআপেক্ষিক, ২-byte এককআপেক্ষিক byte (javap পরম দেখায়)
price-এর আকার১৬টি tuple১৬টি নির্দেশ, ৬৬ byte১৬টি নির্দেশ, ২৭ byte
GlobalLOAD_GLOBAL g, নম্বরLOAD_NAME/LOAD_GLOBAL, dictgetstatic, pool-এর field
Closurecell + MAKE_CLOSUREcell + MAKE_CELL, LOAD_DEREFlambda: invokedynamic, ধরা মান কপি
যাচাইনেইনেইverifier + StackMapTable
গতির কৌশলনেই (পরিষ্কারতা আগে)superinstruction, specialization, পরীক্ষামূলক JITtemplate interpreter, C1/C2 JIT

Closure-এর সারিটি একটু ব্যাখ্যা চায়। Haat আর CPython দুটিই ধরা variable-কে একটি cell-এ রাখে, তাই closure বাইরের variable বদলাতে পারে (পর্ব ১৭, Closure). Java-র lambda শুধু “effectively final” local ধরতে পারে, তাই মান কপি করলেই চলে, cell লাগে না; ভাষার একটি নিয়ম VM-এর কাজ সহজ করেছে। Generic type JVM-এ মুছে যায় (erasure), সেটি পর্ব ৩৭-এ (Generics-এর বাস্তবায়ন); JVM-এর heap আর garbage collector Java কোর্সের পর্ব ৪৪-এ।

৭ · অন্য VM-রা — stack, register আর WebAssembly

সব VM stack-ভিত্তিক নয়। একটি stack machine-এ নির্দেশ ঠিকানা লেখে না, stack-এর ওপর থেকে নেয়: a = b + c হয় চারটি নির্দেশ (load, load, add, store). একটি register VM-এ নির্দেশ নিজেই বলে কোন ঘর থেকে নেবে আর কোথায় রাখবে: একটিই ADD a b c. নির্দেশ কম, তাই dispatch কম; কিন্তু প্রতিটি নির্দেশ বড়, আর compiler-কে ঘর বরাদ্দ করতে হয়।

VMধরনযা জানা দরকার
Lua 5.xregisterLua 5.0 (২০০৩) stack থেকে register VM-এ গিয়েছিল; নকশাকারদের ২০০৫ সালের লেখায় নির্দেশ কম হওয়ার যুক্তি আছে। Local variable সরাসরি register.
BEAM (Erlang, Elixir)registerলক্ষ লক্ষ হালকা process-এর জন্য নকশা; OTP 24 (২০২১) থেকে একটি JIT (BeamAsm) আছে বলে জানা যায়।
.NET CLRstackCIL bytecode, ECMA-335 মান; সাধারণত প্রথমবার চলার আগেই JIT হয়, তাই বিশুদ্ধ interpreter-এর ভূমিকা ছোট।
Dalvik (পুরোনো Android)registerJava-র class ফাইলকে register-ভিত্তিক .dex-এ বদলাত; Android 5.0 (২০১৪) থেকে ART তার জায়গা নিয়েছে।
WebAssemblystack, গঠনবদ্ধমুক্ত goto নেই, block/loop/br; চালানোর আগে এক pass-এ validate হয়; engine সাধারণত machine code-এ compile করে।

Stack আর register-এর বিতর্কের কোনো চিরস্থায়ী বিজয়ী নেই। Stack-এর bytecode ছোট আর compiler সরল (Haat-এর compiler post-order-এ গাছ হাঁটলেই হয়), যা network-এ পাঠানো (JVM-এর applet, WebAssembly) বা দ্রুত compile করার জন্য সুবিধাজনক। আর যে VM শেষ পর্যন্ত JIT দিয়ে machine code বানাবে, তার কাছে bytecode-এর ধরন কম গুরুত্বপূর্ণ, কারণ JIT নিজেই register বরাদ্দ করে (পর্ব ৭০-এ register allocation). WebAssembly-র bytecode হাতে বানিয়ে browser-এ চালানো দেখেছেন পর্ব ০৪-এ; Haat থেকে Wasm তৈরি পর্ব ৭৩-এ (WebAssembly target — Haat থেকে browser-এ চলা code). আর VM নিজেই যে একটি abstract machine-এর বাস্তব রূপ, সেই ধারার শুরু পর্ব ৪০-এর (Operational semantics) small-step নিয়মে।

আরও গভীরে: Bytecode VM-এর ধারণা পুরোনো: UCSD Pascal-এর p-code (১৯৭০-এর দশক) আর Smalltalk-80-এর bytecode VM (১৯৮০-এর দশকের শুরু) Java-র অনেক আগের। Inline cache আর adaptive optimization-এর মূল গবেষণা এসেছে Smalltalk আর Self থেকে (Deutsch–Schiffman ১৯৮৪, পরে Hölzle ও সহকর্মীরা), আর সেই দলের অভিজ্ঞতা পরে HotSpot-এ গেছে বলে ব্যাপকভাবে লেখা হয়। CPython-এর quickening-এর আগে Stefan Brunthaler ২০১০-এর দিকে Python-এ inline caching আর quickening নিয়ে গবেষণা করেছিলেন। আর স্টক বনাম register প্রশ্নে Shi, Gregg, Beatty ও Ertl-এর “Virtual Machine Showdown” (২০০৫) দেখিয়েছিল register-এ বদলালে চলা নির্দেশ উল্লেখযোগ্যভাবে কমে, কিন্তু bytecode বড় হয়।

পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:

  • Stack VM আর register VM-এর পার্থক্য? Stack: নির্দেশ ছোট, সংখ্যায় বেশি, compiler সরল (JVM, CPython, Wasm). Register: নির্দেশ বড়, সংখ্যায় কম, dispatch কম (Lua 5, BEAM).
  • Java কি interpreted ভাষা? না, পুরোপুরি নয়: javac আগে bytecode বানায়; JVM প্রথমে interpret করে, গরম method JIT-এ machine code হয়।
  • JVM-এর bytecode verifier কী করে? চালানোর আগে প্রমাণ করে stack underflow/overflow নেই, প্রতিটি নির্দেশ ঠিক type পায়, jump বৈধ জায়গায়; StackMapTable যাচাইকে এক pass-এ নামায়।
  • Python 3.11-এর পরে কেন দ্রুত? Specializing adaptive interpreter (PEP 659): warm-up-এর পরে সাধারণ নির্দেশ type-নির্দিষ্ট রূপে বদলায়, guard ব্যর্থ হলে সাধারণ পথে ফেরে।
  • javap -c-এ lload_2 কেন, lload_1 নয়, দ্বিতীয় long parameter-এর জন্য? প্রতিটি long দুটি local ঘর নেয়: প্রথম parameter ০–১, দ্বিতীয়টি ২–৩.

৮ · AI-এর যুগে বাস্তব VM

“এই function-এর bytecode দেখাও” বললে AI assistant দ্রুত একটি পরিষ্কার তালিকা দেয়, আর সেটিই বিপদ: তালিকা দেখতে বিশ্বাসযোগ্য, কিন্তু প্রায়ই অন্য version-এর, বা একেবারে বানানো। VM-এর ভেতরের খুঁটিনাটি প্রতি version-এ বদলায় (এই পর্বের LOAD_FAST_BORROW, LOAD_SMALL_INT, NOT_TAKEN 3.14-এর আগে ছিল না), তাই এখানে মুখস্থ উত্তরের চেয়ে নিজে চালানো অনেক বেশি নির্ভরযোগ্য। বারবার দেখা ভুল:

AI-এর ভুলকীভাবে ধরবেন
পুরোনো Python-এর opcode দেখানো (BINARY_MULTIPLY, LOAD_FAST জোড়া ছাড়া)নিজের version-এ dis.dis চালানো, sys.version ছাপিয়ে
Specialized নাম বানিয়ে ফেলা (যেমন int-এর //-এর একটি বিশেষ রূপ)dis._specializations আর dis.dis(f, adaptive=True) warm-up-এর পরে
“Specialization মানে JIT” বা “CPython-এ JIT সবসময় চালু”PEP 659 আর PEP 744 পড়া; version-এর What's New
JVM-এ long-এর local ঘর ভুল গোনা (lload_1), বা stack/locals ভুলjavac + javap -c -v নিজে চালানো
“Verifier ভুল উত্তরও ধরে” বা “CPython bytecode যাচাই করে”বদলানো bytecode-এ চালিয়ে দেখা (নিজের যন্ত্রে, নিজের ফাইলে)
সব VM-কে stack-ভিত্তিক বা সব register-ভিত্তিক বলাপ্রতিটি VM-এর specification বা নকশাকারদের লেখা

AI-কে কাজে লাগানোর ভালো উপায়: version নির্দিষ্ট করে দিন, আর তার কাছে তালিকা নয়, তালিকা বের করার পদ্ধতি চান, যাতে আপনি নিজে চালাতে পারেন।

আমি CPython 3.14 আর Java 21-এর bytecode তুলনা করছি, একটি ছোট function দিয়ে: def price(qty, unit): p = qty * unit; return p - p // 10 if p >= 1000 else p আর Java-তে একই কাজ long দিয়ে। ১. CPython-এর bytecode মুখস্থ থেকে লিখবে না। বরং আমাকে এমন Python কোড দাও যা dis.dis দিয়ে তালিকা ছাপে, আর warm-up-এর পরে adaptive=True দিয়ে আবার ছাপে। ২. Java-র জন্য javac আর javap -c -v-এর ঠিক command দাও, আর বলো আউটপুটে stack, locals আর StackMapTable কীভাবে পড়তে হয়। ৩. কোন opcode-এর নাম version-ভেদে বদলায়, তার একটি সাধারণ সতর্কতা লেখো। ৪. যেখানে নিশ্চিত নও, “নিশ্চিত নই” লেখো; কোনো opcode-এর নাম বানাবে না।

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

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।

প্র ০১Debugger আর profiler কীভাবে একটি VM-এর ভেতরে চোখ রাখে, অথচ সাধারণ run ধীর করে না? CPython-এর NOT_TAKEN আর JVM-এর LineNumberTable এই গল্পে কোথায়?

একটি debugger-এর চাহিদা সরল শোনায়: “লাইন ৪-এ থামো”, “এই শাখা কতবার নেওয়া হলো”, “এই মুহূর্তে p-এর মান কত”. কিন্তু VM-এর হাতে আছে byte offset আর local-এর ঘর-নম্বর, লাইন বা নাম নয়। তাই প্রথম কাজ মানচিত্র রাখা। JVM-এর class ফাইলে প্রতিটি method-এর সঙ্গে LineNumberTable থাকে (ল্যাবের javap -v-এ price-এর জন্য line 3: 0, line 4: 5, line 5: 24), আর javac -g দিলে LocalVariableTable-এ ঘর-নম্বর থেকে নাম। CPython-এর code object-এ একটি location table থাকে; 3.11 থেকে তাতে লাইনের সঙ্গে কলামও (PEP 657), যে কারণে traceback এখন ভুলের নিচে ^^^^ দাগ দিতে পারে। Haat-এর Code.positions একই কাজ করে, প্রতিটি নির্দেশে একটি (line, col), যা runtime error-এর অবস্থান দেয় (decision 26).

দ্বিতীয় কাজ থামা বা খবর দেওয়া, আর এখানে দামের প্রশ্ন। পুরোনো CPython-এ sys.settrace চালু থাকলে প্রতিটি লাইনে একটি Python function ডাকা হতো, তাই debugger-এর নিচে program বহুগুণ ধীর। Python 3.12-এর PEP 669 (sys.monitoring) অন্য পথ নিল: যে code object-এ যে event চাওয়া হয়েছে, শুধু সেখানকার নির্দেশগুলো INSTRUMENTED_ রূপে বদলে দেওয়া হয়, বাকি সব আগের মতো দ্রুত থাকে। ঠিক specialization-এর মতো কৌশল: bytecode জায়গায় বদলানো। এই পর্বের ল্যাবে price-এ branch event চালু করতেই POP_JUMP_IF_FALSE হলো INSTRUMENTED_POP_JUMP_IF_FALSE, আর NOT_TAKEN হলো INSTRUMENTED_NOT_TAKEN; price(2, 520) দিল “left” event (26 থেকে 32, লাফ হয়নি), price(2, 100) দিল “right” (26 থেকে 62). বন্ধ করতেই নামগুলো আগের রূপে ফিরল। তাই NOT_TAKEN সাধারণ run-এ কিছু করে না: সে শুধু “লাফ না-হওয়া পথের” জন্য একটি জায়গা রেখে দেয়, যাতে monitoring চাইলে সেখানে খবর দেওয়া যায়।

JVM-এর দিকে debugger কথা বলে JVMTI (JVM Tool Interface)-এর মাধ্যমে। Specification-এ breakpoint নামে একটি opcode সংরক্ষিত, যা class ফাইলে কখনো থাকে না, শুধু debugger-এর জন্য। আর JIT-এ compile হওয়া method-এ breakpoint বসাতে HotSpot সাধারণত সেই কোড বাতিল করে interpreter-এ ফেরে বলে লেখা হয় (deoptimization, পর্ব ৬১)।

মূল উপলব্ধি: VM-কে পর্যবেক্ষণযোগ্য রাখতে দুটি জিনিস লাগে: offset থেকে লাইন আর নামের মানচিত্র, আর এমন hook যা শুধু চাইলে খরচ করে। আধুনিক VM দ্বিতীয়টি পায় নির্দেশ জায়গায় বদলে, specialization যে কৌশলে চলে সেই একই কৌশলে।

প্র ০২একই গুণের জায়গায় যদি পালা করে একবার int, একবার float আসে, CPython-এর specialization কী করে? JIT-এর জগতে এই সমস্যার নাম আর সমাধান কী?

Specialization একটি বাজি: “এই জায়গায় আবার সেই type আসবে”. Type বদলালে কী হয়, অংশ ৩-এ দেখেছেন: ৫২টি ব্যর্থতার পরে নির্দেশ নতুন type-এ বদলায়। কিন্তু দুই type যদি সমানভাবে মিশে আসে? ল্যাবে (CPython 3.14.4) price-কে ২০০০ বার ডাকা হলো, বিজোড় ডাকে (2, 520), জোড় ডাকে (2.5, 520.0). গুণের নির্দেশের নাম ২০০০ ডাকে ২১ বার বদলেছে: প্রায় প্রতি ১০৫ ডাকে একবার, ..._FLOAT থেকে ..._INT, আবার ..._FLOAT. যে type-এই থাকুক, পরের ডাকের অন্য type-টি guard-এ ব্যর্থ হয়, তাই মোটামুটি অর্ধেক ডাক সাধারণ পথে চলে। ফল সবসময় ঠিক, কিন্তু বিশেষ রূপের লাভ অর্ধেক।

JIT আর dynamic ভাষার গবেষণায় এই ধরনের জায়গাকে বলে polymorphic (কয়েকটি type) বা megamorphic (অনেক type). Smalltalk আর Self-এর যুগ থেকে এর প্রচলিত সমাধান polymorphic inline cache: একটি জায়গায় একটির বদলে কয়েকটি type আর তাদের পথ মনে রাখা (Hölzle, Chambers আর Ungar ১৯৯১ সালের দিকে এর পরিচিত বর্ণনা দেন)। V8-এর মতো engine-ও একই ধারণায় চলে বলে জানা যায়: কয়েকটি আকার পর্যন্ত তালিকা, তার বেশি হলে সাধারণ পথ। CPython-এর specialization বেশিরভাগ জায়গায় একটি type-এর (monomorphic), কারণ নির্দেশ জায়গায় বদলানো হয় আর CACHE-এর জায়গা ছোট; কিছু মিশ্র ক্ষেত্রের জন্য 3.14-এ BINARY_OP_EXTEND নামের একটি সাধারণ বিশেষ রূপও আছে বলে জানা যায়। Backoff counter আরেকটি রক্ষাকবচ: বারবার ব্যর্থ হলে চেষ্টার ব্যবধান বাড়ে, যাতে বদলানোর খরচ নিজেই বোঝা না হয় (//-এর counter-এর 2, 1, 0, 6 লাফে এটিই দেখেছেন)।

প্রোগ্রামারের জন্য শিক্ষাটি ব্যবহারিক: dynamic ভাষায়ও একটি জায়গায় এক type রাখা কোডকে দ্রুত রাখে। বাজারঘরের হিসাবে কোথাও int আর কোথাও float মেশালে, সঠিকতা বদলায় না, কিন্তু VM-এর অনুমান বারবার ভাঙে। Haat-এ প্রশ্নটিই ওঠে না: type checker আগেই নিশ্চিত করে qty * unit সবসময় Int (decision 11).

মূল উপলব্ধি: specialization ও inline cache “বেশিরভাগ জায়গা এক type দেখে” পর্যবেক্ষণের ওপর দাঁড়ানো; যেখানে তা সত্য নয়, সেখানে VM-কে হয় কয়েকটি type মনে রাখতে হয়, নয়তো সাধারণ পথে থেকে চেষ্টার খরচ সীমিত রাখতে হয়।

প্র ০৩CPython কেন প্রথমে JIT নয়, specializing interpreter বানাল? আর Haat statically typed হয়েও কি এই ধারণা থেকে কিছু নিতে পারে?

PEP 659-এর যুক্তি ছিল ব্যবহারিক। CPython চলে অসংখ্য platform-এ, আর তার শক্তি C extension-এর বিশাল জগৎ (NumPy থেকে শুরু করে)। একটি JIT মানে প্রতিটি CPU-র জন্য machine code তৈরি, executable মেমরি সামলানো, debugger আর profiler-এর সঙ্গে মেলানো, আর C extension-এর সঙ্গে সামঞ্জস্য রাখা। PyPy প্রমাণ করেছিল Python-এর জন্য JIT দারুণ গতি দিতে পারে, কিন্তু C extension-এর সঙ্গে মেলাতে তার দীর্ঘ সংগ্রামও সবার জানা। Specializing interpreter এই সব ঝামেলা এড়ায়: সব বিশেষ নির্দেশ আগে থেকেই C-তে লেখা, তাই নতুন platform-এ কোনো বাড়তি কাজ নেই, আর ব্যর্থ হলে সাধারণ পথ সবসময় খোলা।

দ্বিতীয় যুক্তি ছিল ধাপে ধাপে এগোনো। Specialization যে তথ্য জোগাড় করে (কোন জায়গায় কোন type আসে), পরে JIT ঠিক সেটিই চায়। CPython 3.13-এর পরীক্ষামূলক JIT (PEP 744, copy-and-patch কৌশল) এই বিশেষ নির্দেশের ক্রম থেকেই কাজ শুরু করে। অর্থাৎ interpreter-টি পরের ধাপের ভিত।

Haat-এর ক্ষেত্রে ছবিটি উল্টো। Type checker আগেই জানে p - p / 10-এ সব Int, তাই চলার সময় অনুমানের দরকার নেই: compiler সরাসরি SUB_INT, DIV_INT লিখতে পারত, আর +-এর জন্য ADD_INT বা CONCAT. এটি JVM-এর পথ: ladd আর string জোড়ার কাজ আলাদা। এতে VM-এর ADD-এর ভেতরের type-পরীক্ষা চলে যায়। তবু Haat একটি জায়গায় specialization থেকে শিখতে পারে: function call. CALL n প্রতিবার দেখে callee কোন closure; একটি জায়গা যদি সবসময় একই function ডাকে (যেমন price), তাহলে একটি inline cache মনে রাখতে পারে “গতবারও এই closure ছিল”, যাতে পরের বার frame তৈরির প্রস্তুতি দ্রুত হয়। আর superinstruction সরাসরি নেওয়া যায়, যদিও লাভ মেপে দেখতে হয়: অনুশীলন ১-এ LOAD_LOCAL জোড়া মিলিয়ে bazar-এ চলা নির্দেশ কমেছে মাত্র ১২০ থেকে ১১৬.

মূল উপলব্ধি: specialization হলো run time-এ type শেখা। Static type থাকলে সেই শেখা compile time-এ একবারেই হয়ে যায়; বাকি থাকে শুধু সেই তথ্য, যা static type জানায় না, যেমন কোন function আসলে ডাকা হচ্ছে।

প্র ০৪Haat-এর jump-এর লক্ষ্য পরম নির্দেশ-নম্বর (decision 28), CPython আর JVM-এর আপেক্ষিক byte-হিসাব। বাস্তব VM কেন এই জটিলতা নেয়?

Haat-এর Code.instrs Python-এর tuple-এর তালিকা; নির্দেশের “আকার” বলে কিছু নেই, তাই ক্রমিক নম্বরই সবচেয়ে পরিষ্কার ঠিকানা। dis-এর JUMP 22 পড়ে যে কেউ তালিকার ২২ নম্বর সারি খুঁজে পান। শেখার জন্য এটি আদর্শ।

বাস্তব VM-কে bytecode ফাইলে লিখতে হয়, মেমরিতে ঘন করে রাখতে হয়, আর CPU-র cache-এ যত কম জায়গা নেয় তত ভালো। তাই নির্দেশ byte-এ মাপা: JVM-এ একটি opcode এক byte, পেছনে operand; CPython-এ প্রতিটি নির্দেশ দুই byte-এর একক, কিছু নির্দেশের পেছনে CACHE. Byte-এ মাপলে ঠিকানাও byte-এ হয়।

আপেক্ষিক কেন? প্রথমত ছোট সংখ্যা: বেশিরভাগ jump কাছাকাছি যায়, তাই ছোট একটি সংখ্যাই যথেষ্ট। JVM-এর branch-এ ১৬-বিটের চিহ্নযুক্ত দূরত্ব, আর CPython-এর argument সাধারণত এক byte; বড় হলে EXTENDED_ARG নামের আগাম নির্দেশ লাগে। দ্বিতীয়ত সরানো যায়: আপেক্ষিক jump-এর কোড অন্য জায়গায় বসালেও ঠিক থাকে। তৃতীয়ত দিক বোঝা যায়: CPython-এর JUMP_BACKWARD আলাদা নির্দেশ, কারণ পেছনের jump মানে loop, আর loop-এর মাথায় interpreter অন্য thread বা signal-এর জন্য থামার সুযোগ দেয়, specialization-এর counter-ও সেখানে কাজ করে।

এর দামও আছে। JVM-এ একটি method-এর কোড ৬৪ KB-এর কম হতে হয়, কারণ offset ১৬-বিট; খুব বড় তৈরি-করা method (কিছু code generator-এর ফল) এই সীমায় আটকায়। CPython-এর specialization নির্দেশের আকার বদলাতে পারে না, তাই CACHE-এর জায়গা আগেই রাখা: নইলে প্রতিটি বদলে jump-এর হিসাব ভাঙত। এই পর্বের stepper-এ POP_JUMP_IF_FALSE 16-কে 62-তে অনুবাদ করতে CACHE গুনতে হয়েছিল ঠিক এ কারণে।

মূল উপলব্ধি: ঠিকানার ধরন একটি আপস: পরম নম্বর পড়তে সহজ, আপেক্ষিক byte ঘন আর সরানো যায়। Haat শিক্ষার জন্য প্রথমটি নিয়েছে, ফাইলে লেখা বাস্তব VM দ্বিতীয়টি।

প্র ০৫JVM-এ আজ Java ছাড়াও Kotlin, Scala, Clojure চলে; BEAM-এ Elixir, .NET-এ C# আর F#. Haat-কে JVM-এ চালাতে চাইলে কী কী বদলাতে হবে, আর কী পাওয়া যাবে?

একটি জনপ্রিয় VM নিজেই একটি platform: garbage collector, JIT, thread, debugger, profiler আর বিশাল library সব তৈরি। নতুন ভাষা সেই VM-এর bytecode লিখলেই এসব পায়। Kotlin আর Scala JVM-এর class ফাইল লেখে; Clojure, একটি LISP, চলার সময়ও class বানায়। Java 7-এ (২০১১) যোগ হওয়া invokedynamic মূলত এমন ভাষার জন্যই, যাদের method খোঁজার নিয়ম Java-র মতো নয়; পরে Java নিজেই lambda আর string জোড়ায় এটি ব্যবহার করছে, যা এই পর্বের Java ব্লকের ১১৬টি pool-ঘরে দেখলেন। .NET শুরু থেকেই বহু ভাষার জন্য নকশা করা (Common Language Infrastructure, ECMA-335).

Haat-এর জন্য মানচিত্রটি এরকম। Int → long, আর + - *-এ wrap Java-তে বিনামূল্যে (decision 13). / আর %-ও শূন্যের দিকে কাটে, আর Java-তে Long.MIN_VALUE / -1 নিজেই wrap করে বলে Java Language Specification বলে; কেবল শূন্য দিয়ে ভাগে ArithmeticException-কে Haat-এর runtime error: division by zero-এ বদলাতে হবে, অবস্থানসহ। Bool → int 0/1, Str → java.lang.String, print → System.out.println. Top-level function → static method, top-level variable → static field (LOAD_GLOBAL-এর বদলে getstatic, আর decision 18-এর “not initialized yet” পরীক্ষা নিজে বসাতে হবে)।

কঠিন অংশ closure. Haat-এর closure বাইরের var বদলাতে পারে, Java-র lambda পারে না। তাই প্রতিটি ধরা variable-এর জন্য একটি ছোট cell class (এক ঘরের বাক্স) লাগবে, আর প্রতিটি নামহীন function একটি class বা invokedynamic-এর lambda. ১০০০-ডাকের সীমা (decision 26) নিজে গুনতে হবে, কারণ JVM-এর StackOverflowError অনেক গভীরে আসে। আর javac-এর মতো StackMapTable নিজে লিখতে হবে, নইলে verifier class-টিই নেবে না। লাভ বিশাল: HotSpot-এর JIT Haat-এর price-কে machine code বানাবে, garbage collector তৈরি, আর Java-র যেকোনো library ডাকা যাবে।

মূল উপলব্ধি: নিজের VM মানে পূর্ণ নিয়ন্ত্রণ আর সরলতা; বড় VM-এ চড়া মানে তৈরি গতি আর ecosystem, কিন্তু নিজের semantics তার নিয়মে, যেমন verifier আর lambda-র সীমা, খাপ খাওয়ানোর কাজ।

অনুশীলন

প্রথমে নিজে করুন, তারপর উত্তর খুলে মেলান। প্রতিটি সংখ্যা ল্যাবের সত্যিকারের run থেকে।

  1. নকশা ও বাস্তবায়ন — Haat-এ CPython-এর মতো একটি superinstruction: compile-এর পরে একটি pass লিখুন যা পরপর দুটি LOAD_LOCAL a, LOAD_LOCAL b-কে একটি LOAD_LOCAL2 (a, b)-এ জোড়ে, আর VM-এ তার handler যোগ করুন। মনে রাখুন Haat-এর jump-এর argument পরম নির্দেশ-নম্বর (decision 28): একটি নির্দেশ কমলে পরের সব নম্বর সরে যায়। তারপর reference-এর উদাহরণে মাপুন: আউটপুট কি বদলায়, আর চলা নির্দেশ কত কমে?

    দুটি কাজ: জোড়া, আর প্রতিটি পুরোনো নম্বর নতুন কোথায় গেল তার মানচিত্র (where) রেখে শেষে সব jump নতুন করে লেখা। দ্বিতীয় load-টি যদি নিজেই কোনো jump-এর লক্ষ্য হয়, তাহলে জোড়া চলবে না (অনুশীলন ৪). ল্যাবে চালানো সংস্করণ:

    JUMPS = ("JUMP", "JUMP_IF_FALSE")
    def fuse(code):
        """LOAD_LOCAL a; LOAD_LOCAL b  ->  LOAD_LOCAL2 (a, b), jump-এর লক্ষ্য ঠিক রেখে"""
        old, pos = code.instrs, code.positions
        targets = {arg for op, arg in old if op in JUMPS}
        new, newpos, where = [], [], {}
        i = 0
        while i < len(old):
            where[i] = len(new)
            if (old[i][0] == "LOAD_LOCAL" and i + 1 < len(old)
                    and old[i + 1][0] == "LOAD_LOCAL" and i + 1 not in targets):
                new.append(("LOAD_LOCAL2", (old[i][1], old[i + 1][1]))); newpos.append(pos[i])
                where[i + 1] = len(new) - 1
                i += 2
            else:
                new.append(old[i]); newpos.append(pos[i]); i += 1
        where[len(old)] = len(new)
        code.instrs = [(op, where[arg]) if op in JUMPS else (op, arg) for op, arg in new]
        code.positions = newpos
        for c in code.consts:                      # ভেতরের function-গুলোও
            if isinstance(c, Code): fuse(c)
    
    # vm.py-র একটি কপিতে (ল্যাবে), LOAD_LOCAL-এর ঠিক পরে:
    #   elif op == "LOAD_LOCAL2":
    #       stack.append(f.slots[arg[0]]); stack.append(f.slots[arg[1]])

    একটি loop-ওয়ালা function-এ ফলটি এরকম (while i < qty { t = t + unit; i = i + 1; }, সত্যিকারের listing):

    আগে                         পরে
     4  LOAD_LOCAL     2          4  LOAD_LOCAL2    2, 0
     5  LOAD_LOCAL     0          5  LT
     6  LT                        6  JUMP_IF_FALSE  15
     7  JUMP_IF_FALSE  17         7  LOAD_LOCAL2    3, 1
     8  LOAD_LOCAL     3          ...
     9  LOAD_LOCAL     1         14  JUMP           4
    ...                          15  LOAD_LOCAL     3
    16  JUMP           4         16  RETURN
    17  LOAD_LOCAL     3
    18  RETURN

    ল্যাবের ফল: reference-এর ১০টি চালানো যায় এমন উদাহরণের সবকটিতে আউটপুট হুবহু এক; মোট ৭টি জায়গায় জোড়া লেগেছে। চলা নির্দেশ: bazar.haat ১২০ থেকে ১১৬ (price-এর দুটি জোড়া, দুবার ডাকা), কিন্তু দশটি মিলিয়ে ২৪৪৩৪৭ থেকে মাত্র ২৪৪৩৩৭, কারণ সবচেয়ে ভারী recursion.haat-এর fib আর fact-এ পরপর দুটি LOAD_LOCAL নেই (সেখানে LOAD_LOCAL-এর পরে আসে CONST). শিক্ষা: superinstruction বাছতে হয় মেপে, কোন জোড়া আসলে সবচেয়ে বেশি চলে (পর্ব ৫৯-এর profiler দিয়ে)। CPython-এর LOAD_FAST_LOAD_FAST পরিবারও এভাবেই এসেছে বলে জানা যায়। আর jump নতুন করে না লিখলে? ওপরের loop function-টি IndexError: list index out of range-এ ভেঙেছে: পুরোনো JUMP_IF_FALSE 17 এখন ১৭টি নির্দেশের তালিকার বাইরে।

  2. ভুল খুঁজুন — “verifier থাকলে bytecode বদলে ভুল উত্তর পাওয়া অসম্ভব”: একজন সহকর্মী বললেন: “JVM-এর verifier class ফাইলের যেকোনো বদল ধরে, তাই JVM-এ bytecode বদলে ভুল উত্তর পাওয়া অসম্ভব।” তিনি প্রমাণ হিসেবে lmul থেকে imul বদলের VerifyError দেখালেন। price-এর 1: lload_2-কে 1: lconst_1 করলে (দুটিই এক byte) কী হবে? main কী ছাপবে? দাবির ভুল কোথায়?

    lconst_1 stack-এ long 1 তোলে, lload_2 তুলত long unit. Verifier-এর চোখে দুটিই “একটি long, দুই ঘর”, তাই stack-এর আকার আর type হুবহু এক: class বৈধ। ল্যাবে সত্যিকারের run (Temurin 21.0.13):

    $ java -cp bad2 Bazar
    62
    5000
    3

    price(2, 520) এখন 2 × 1 = 2 দেয় (1000-এর কম, তাই ছাড় নেই), delivery(2) = 60, মোট 62. Haat VM-এ একই ধরনের বদল (LOAD_LOCAL 1 → CONST 0) 1800-এর হিসাব দিয়েছিল, আর stack-গভীরতার checker-ও সেটি পাস করিয়েছিল (অংশ ৫)।

    দাবির ভুল: verifier প্রমাণ করে type-safety (VM-এর নিজের নিয়ম ভাঙবে না: stack, type, jump, access), program-এর অর্থ নয়। কোন সংখ্যা গুণ হবে, তা verifier জানে না, জানার কথাও নয়। Class ফাইলের অখণ্ডতা চাইলে আলাদা ব্যবস্থা লাগে (যেমন JAR-এ digital signature), আর compiler-এর সঠিকতার জন্য test আর differential testing.

  3. Trace আর হিসাব — JVM-এ delivery(936): javap-এর সত্যিকারের আউটপুট:
    static long delivery(long);
      stack=4, locals=2, args_size=1
         0: lload_0
         1: ldc2_w        #7                  // long 1000l
         4: lcmp
         5: iflt          10
         8: lconst_0
         9: lreturn
        10: ldc2_w        #11                 // long 60l
        13: lreturn
    প্রতিটি চলা নির্দেশের পরে operand stack লিখুন। কোন নির্দেশগুলো চলবে? ফেরত মান কত? stack=4 আর locals=2 কেন?
    1. 0: lload_0 → [936] (২ ঘর).
    2. 1: ldc2_w #7 → [936, 1000] (৪ ঘর, সবচেয়ে গভীর).
    3. 4: lcmp → 936 < 1000, তাই int -1: [-1] (১ ঘর).
    4. 5: iflt 10 → -1 < 0, তাই লাফ; stack খালি। 8 আর 9 চলে না।
    5. 10: ldc2_w #11 → [60].
    6. 13: lreturn → 60 ফেরত।

    চলেছে ৫টি নির্দেশ। locals=2: একটিই long parameter, দুই ঘর। stack=4: সবচেয়ে গভীর মুহূর্তে দুটি long. ফল মেলে: main ছেপেছিল 996 = 936 + 60. Haat-এর একই function (delivery, ৮টি নির্দেশ) একই পথে চলে: LOAD_LOCAL 0, CONST 0, GE, JUMP_IF_FALSE 6 (লাফ), CONST 2, RETURN: ৬টি নির্দেশ, কারণ Haat-এর GE নিজেই Bool দেয়, JVM-এর মতো lcmp + iflt দুই ধাপে নয়। আর পর্ব ৫৮-এর গভীরতা-হিসাবে Haat-এর delivery-র সর্বোচ্চ গভীরতা 2: সেখানে মান গোনা হয়, ঘর নয়।

  4. প্রমাণ — superinstruction-এর pass অর্থ বদলায় না: অনুশীলন ১-এর fuse-এর জন্য দেখান: প্রতিটি function-এর জন্য, মূল কোড আর জোড়া কোড একই input-এ একই ক্রমে একই মান ছাপে, একই মান ফেরত দেয় আর একই runtime error দেয়। কেন শর্ত “দ্বিতীয় load কোনো jump-এর লক্ষ্য নয়” দরকার, একটি ছোট উদাহরণে দেখান।

    প্রমাণের রূপরেখা (simulation): মূল কোডের অবস্থা (ip, stack, slots, …) আর জোড়া কোডের অবস্থা (ip′, stack, slots, …)-কে “মিলছে” বলি যদি ip′ = where[ip] আর বাকি সব হুবহু এক, এবং ip কোনো জোড়ার দ্বিতীয় নির্দেশ নয়।

    1. শুরু: দুটিই ip = 0-তে, where[0] = 0, stack আর slots একই। মিলছে।
    2. জোড়া নয় এমন নির্দেশ: মূল কোড ip-তে (op, arg) চালায়, জোড়া কোড where[ip]-তে একই opcode চালায়। JUMP/JUMP_IF_FALSE ছাড়া argument একই, তাই ফল একই, আর পরের অবস্থা ip + 1 বনাম where[ip] + 1 = where[ip + 1] (মাঝে কিছু বাদ পড়েনি)। Jump-এ মূল কোড t-তে যায়, জোড়া কোড where[t]-তে। t যেহেতু কোনো জোড়ার দ্বিতীয় নির্দেশ নয় (শর্ত), নতুন অবস্থাও মিলছে।
    3. জোড়া: মূল কোড ip-তে LOAD_LOCAL a, ip + 1-এ LOAD_LOCAL b চালায়: দুই ধাপে slots[a] আর slots[b] তোলে। জোড়া কোড এক ধাপে ঠিক একই দুটি মান একই ক্রমে তোলে। দুটি load-এর কোনোটিই কিছু ছাপে না, error দেয় না, slots বদলায় না, তাই মাঝের অবস্থা বাইরে থেকে দেখা যায় না। শেষে ip + 2 বনাম where[ip] + 1 = where[ip + 2]: মিলছে।
    4. উপসংহার: প্রতিটি ধাপে মিল থাকে, আর ছাপা, ফেরত আর error হয় শুধু জোড়া নয় এমন নির্দেশে, একই ক্রমে। তাই দুটি কোড বাইরে থেকে একই আচরণ দেখায়, আর জোড়া কোডে চলা নির্দেশ ঠিক জোড়ার সংখ্যা যতবার চলেছে ততগুলো কম। ∎

    শর্তটি কেন: ধরুন ৪-এ LOAD_LOCAL 0, ৫-এ LOAD_LOCAL 1, আর কোথাও JUMP 5 আছে (অন্য পথে একটি মান আগে stack-এ রেখে ৫-এ আসে)। জোড়ার পরে ৪ আর ৫ একটিই নির্দেশ; where[5]-এ লাফালে সেই পথ দুটি মান তোলে, একটির বদলে: stack-এ একটি বাড়তি মান, আর প্রমাণের ধাপ ২ ভেঙে যায়। Haat-এর compiler এমন কোড বানায় না: jump-এর লক্ষ্য সবসময় একটি statement-এর শুরু, বা &&/||-এর শেষ, যার ঠিক আগে কখনো LOAD_LOCAL থাকে না। ল্যাবে শর্তসহ আর শর্ত ছাড়া pass ১০টি উদাহরণে হুবহু একই bytecode দিয়েছে। তবু pass-টি শুধু এই compiler-এর জন্য নয়, যেকোনো বৈধ bytecode-এর জন্য সঠিক হওয়া উচিত; শর্তটি সেই নিশ্চয়তা দেয়।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমএকটি Java 21 method লেখা থেকে HotSpot JVM-এ গরম হয়ে ওঠা পর্যন্ত ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. javac source থেকে class ফাইল লেখে, সঙ্গে StackMapTable
  2. Class loader ফাইলটি পড়ে, magic আর version দেখে
  3. Verifier প্রতিটি method-এর stack আর type যাচাই করে
  4. Interpreter bytecode একটি একটি করে চালায়
  5. বারবার চলা method JIT-এ machine code হয়

CPython 3.14-এ def area(w, h): return w * h-কে দুটি int দিয়ে কয়েকবার ডাকার পরে dis.dis(area, adaptive=True)-এ গুণের নির্দেশ কোন নামে দেখাবে?

  • BINARY_MULTIPLY
  • imul
  • BINARY_OP_MULTIPLY_INT
  • BINARY_OP, কারণ dis কখনো বদলানো রূপ দেখায় না

Java 21-এ static long price(long qty, long unit) { long p = qty * unit; … }. javap -c-এ p-কে রাখার নির্দেশ কোনটি?

  • lstore_2
  • lstore 4
  • istore_3
  • STORE_FAST p

একটি বৈধ class ফাইলের একটি method-এ lmul-এর byte বদলে imul করা হলো, যেখানে stack-এ দুটি long ছিল। HotSpot JVM (Java 21)-এ চালালে কী হবে?

  • দুটি long-এর নিচের অর্ধেক গুণ হয়ে ভুল উত্তর আসবে
  • Method-এর ওই লাইনে পৌঁছালে তবেই একটি exception আসবে
  • JVM process crash করবে (segmentation fault)
  • চালানোর আগেই VerifyError, কোনো লাইন চলবে না

CPython 3.14-এর dis-এ offset 26-এ POP_JUMP_IF_FALSE 16, আর তার পেছনে একটি CACHE একক (offset 28), তাই পরের নির্দেশ offset 30-এ। লাফ হলে লক্ষ্য কোন offset?

  • 62
  • 16
  • 42
  • 46

নিচের কোন VM register-ভিত্তিক bytecode ব্যবহার করে?

  • HotSpot JVM
  • CPython
  • Lua 5.x
  • WebAssembly

একটি Haat-এর মতো stack VM-এর verifier প্রতিটি নির্দেশে stack-গভীরতা গোনে আর সব পথ মেলায়। bytecode-এ LOAD_LOCAL 1-কে CONST 0 (মান 1000) দিয়ে বদলালে কী হবে?

  • Verifier গভীরতার অমিল ধরে বাতিল করবে
  • Verifier পাস করাবে, program চলে ভুল উত্তর দেবে
  • চলার সময় stack underflow হবে
  • Type checker type mismatch দেবে

CPython 3.14.4-এ p - p // 10-কে int দিয়ে অনেকবার চালানোর পরে - হয় BINARY_OP_SUBTRACT_INT, কিন্তু // সাধারণ BINARY_OP-ই থাকে। কারণ কী?

  • // যথেষ্টবার চলেনি
  • একটি লাইনে কেবল একটি নির্দেশ বদলাতে পারে
  • // কখনো কখনো float দেয়, তাই অনুমান নিরাপদ নয়
  • ওই version-এ int-এর //-এর কোনো বিশেষ নির্দেশই নেই

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. একই হাড়গোড়: Haat VM, CPython আর JVM তিনটিই stack machine; ধ্রুবক, local ঘর, operand stack, শর্তসহ jump আর call/return সবখানে আছে।
  2. CPython 3.14: byte offset, CACHE ঘর, superinstruction আর আপেক্ষিক jump; frame-এ local-এর পরে co_stacksize-মাপের stack.
  3. PEP 659: দ্বিতীয় execution-এ নির্দেশ type-নির্দিষ্ট রূপ পায়, guard ব্যর্থ হলে সাধারণ পথে চলে, ৫২টি ব্যর্থতার পরে আবার বদলায়; machine code নেই।
  4. JVM: class ফাইল, একটি constant pool, typed নির্দেশ, long-এর দুই ঘর, আর চালানোর আগে StackMapTable-সহ verifier.
  5. Verifier নিরাপত্তা দেয়, সঠিকতা নয়: stack আর type-এর ভুল ধরে, ভুল ধ্রুবক ধরে না; সঠিকতার জন্য test আর differential testing.

পরের পর্বে: CPython-এর specialization machine code বানায় না, HotSpot বানায়। পর্ব ৬১-এ (JIT compilation — profiling, tracing আর deoptimization) দেখবেন গরম কোড কীভাবে চেনা হয়, method JIT আর tracing JIT-এর পার্থক্য, অনুমান ভাঙলে deoptimization, আর Haat-এর জন্য একটি ছোট JIT.

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান