এই পর্বে যা শিখবেন
- Interpreter কোথায় সময় হারায়, আর JIT কেন “কখন” আর “কী” compile করবে আগে ঠিক করে
- Profiling, hotness counter, tiered compilation আর on-stack replacement-এর কাজ
- Haat bytecode থেকে চলার সময় কোড বানানো: basic block, symbolic stack আর guard
- Speculation আর deoptimization-এর সঠিকতার শর্ত, আর তার প্রমাণের রূপরেখা
- Method JIT বনাম tracing JIT, আর V8, HotSpot, CPython 3.14 ও PyPy বাস্তবে কী করে, নিজের যন্ত্রে মেপে
১ · Interpreter-এর খরচ আর JIT-এর ধারণা
পর্ব ৫৬-এর শেষে একটি সংখ্যা ছিল: একই fib(22) সরাসরি Python-এ লিখলে Haat-এর tree-walking interpreter-এর চেয়ে প্রায় ১৩০ গুণ দ্রুত। পর্ব ৫৮-এ AST-কে সমতল bytecode-এ নামানো হলো, আর পর্ব ৫৯-এ সেই bytecode চালানোর loop. তবু একটি virtual machine প্রতিটি নির্দেশে একই তিনটি কাজ করে: পরের নির্দেশ পড়া (fetch), কোন opcode তা বোঝা (decode: reference-এর vm.py-তে if/elif-এর শিকল, পর্ব ৫৯-এর VM-এ একটি table), তারপর আসল কাজ। LOAD_LOCAL 2-এর আসল কাজ একটি list থেকে একটি মান পড়া; বাকি সবটাই খরচ। এই খরচকে বলে interpretation overhead.
Just-in-time (JIT) compiler এই খরচ সরায়: program চলার সময়ই কিছু অংশকে সরাসরি চলার উপযোগী কোডে (সাধারণত machine code) অনুবাদ করে, যাতে আর fetch-decode লাগে না। পর্ব ০৪-এ দেখেছেন, JIT-এর আসল শক্তি তথ্য: চলার সময় সে জানে কোন শাখা আসলে নেওয়া হয়, কোন function গরম। এই পর্বে তথ্য সংগ্রহ (profiling), অনুমান (speculation) আর অনুমান ভাঙলে ফেরা (deoptimization), তিনটিই হাতে-কলমে।
নতুন একজন দোভাষীর কথা ভাবুন, যিনি একটি দোকানের বিদেশি খদ্দেরের প্রতিটি বাক্য অভিধান দেখে দেখে অনুবাদ করেন (interpreter). সপ্তাহখানেক পরে তিনি দেখেন, দশটি বাক্যের আটটিই “এটার দাম কত?” আর “ডেলিভারি কবে?”; এ দুটির অনুবাদ তিনি মুখস্থ করে ফেলেন (JIT compile). মুখস্থ করার সময় তিনি একটি অনুমানও করেছেন: “খদ্দের সবসময় টাকায় দাম চান।” একদিন একজন ডলারে দাম চাইলেন: মুখস্থ উত্তর ভুল, তাই তিনি থেমে আবার অভিধান খুললেন (deoptimization). কোন বাক্য মুখস্থ হবে, তা ঠিক করেছে গোনা।
বাস্তবের engine একটি নয়, কয়েকটি স্তর রাখে (tiered compilation): শুরুতে interpreter, কারণ সে সঙ্গে সঙ্গে চালাতে পারে; একটু গরম হলে একটি দ্রুত কিন্তু কম-optimize-করা compiler; খুব গরম হলে ধীরে compile করা কিন্তু অনেক বেশি optimize-করা compiler. নিচের ছবিতে মূল কাঠামো আর দুটি বাস্তব engine-এর স্তরের নাম, যা version-ভেদে বদলায়।
ছবি ৬১.১ — স্তরের সিঁড়ি: নিচে নামা মানে বেশি গরম, বেশি optimize
বাঁ দিকে স্তরের কাজ, বাক্সের নিচের লাইনে V8 (Node 24) আর HotSpot JVM-এর নাম; ডান দিকের তির deoptimization, যা যেকোনো compile-করা স্তর থেকে interpreter-এ ফেরায়।
স্তরগুলো আসলে কত পার্থক্য করে? লেখকের যন্ত্রে Node 24.15.0 (V8 13.6) দিয়ে একই price function দুই কোটি বার ডাকা হলো, প্রতিবার কিছু স্তর বন্ধ রেখে। সত্যিকারের run; তিনবার চালিয়ে প্রতিবার কাছাকাছি সময় এসেছে, নিচে প্রথমবারের। এটি শুধু ধারণা দেওয়ার জন্য, benchmark নয় (Windows, x86-64):
$ node v8time.js # সব স্তর চালু
sum 14759998416 time 29 ms
$ node --no-maglev --no-turbofan v8time.js # Ignition + Sparkplug
sum 14759998416 time 405 ms
$ node --no-sparkplug --no-maglev --no-turbofan v8time.js # শুধু Ignition
sum 14759998416 time 704 ms
$ node --jitless v8time.js # কোনো executable কোডই তৈরি নয়
sum 14759998416 time 716 ms
ফল একই, সময় প্রায় পঁচিশ গুণ আলাদা। Baseline compiler (Sparkplug) প্রায় কোনো optimization করে না, শুধু প্রতিটি bytecode-কে machine code-এর টুকরোয় বদলে fetch-decode সরায়, তাতেই সময় প্রায় ৪০% কমে। বাকি বিশাল লাভ optimizing স্তরের, যারা profile দেখে অনুমান করে।
২ · Profiling — কোন কোড গরম, কোন শাখা ঠান্ডা
JIT সব কোড compile করে না, কারণ compile করারও খরচ আছে: যে function একবার চলে, তাকে compile করা লোকসান। তাই interpreter নিজেই একটি profiler-এর কাজ করে, তিন রকম তথ্য রাখে:
- Hotness counter: প্রতিটি function কতবার ডাকা হলো, প্রতিটি loop-এর পেছনের লাফ (back edge) কতবার চলল। একটি সীমা (threshold) পেরোলে compile. Node 24-এর V8-এ
node --v8-optionsএর জন্য ডিফল্ট দেখায়--invocation-count-for-maglev=400আর--invocation-count-for-turbofan=3000; তবে V8 এই সংখ্যার সঙ্গে function-এর আকার আর অন্য হিসাবও মেলায়, তাই “ঠিক ৪০০তম call-এ” ধরে নেবেন না। - Branch profile: প্রতিটি শর্তসাপেক্ষ লাফ কোন দিকে কতবার গেল।
- Type feedback: প্রতিটি operation-এ কোন type-এর মান এল, যেমন
+-এ দুটি সংখ্যা না দুটি string. পর্ব ০৮-এর inline cache আর পর্ব ১২-এর CPython-এর specializing interpreter (বিস্তারে পর্ব ৬০) এই তথ্যেরই দুই রূপ।
Haat-এ তৃতীয়টির দরকার খুব কম: type checker (পর্ব ৫২) আগেই প্রমাণ করেছে যে প্রতিটি +-এর দুই পাশ হয় দুটি Int, নয় দুটি Str, আর একই জায়গায় কখনো বদলায় না। JavaScript-এ a + b-এ যেকোনো কিছু আসতে পারে, তাই V8-কে type অনুমান করে পাহারা বসাতে হয়। Haat-এর JIT শুধু দেখে একটি ADD Str জোড়ে না Int যোগ করে, কারণ bytecode-এ দুটির opcode একই। কিন্তু শাখার profile Haat-এও পুরো কাজে লাগে: কোন শাখা নেওয়া হবে, তা কোনো type checker জানে না।
নিচের পরীক্ষার program hot.haat. প্রথম loop ৩০০টি ছোট অর্ডার পাঠায় (qty ১ থেকে ৭, তাই দাম সবসময় ১,০০০ টাকার নিচে), তারপর একটি বড় অর্ডার, তারপর ১০০টি মেশানো অর্ডার (qty ১২ পর্যন্ত, তাই কিছু অর্ডারে ছাড়):
// বাজারঘর: ৩০০টি ছোট অর্ডার, একটি বড়, তারপর মেশানো ১০০টি
fn price(qty: Int, unit: Int) -> Int {
let p = qty * unit;
if p >= 1000 { return p - p / 10; }
return p;
}
var i = 0;
var sum = 0;
while i < 300 {
sum = sum + price(i % 7 + 1, 120);
i = i + 1;
}
print(sum);
print(price(10, 120));
var j = 0;
while j < 100 {
sum = sum + price(j % 12 + 1, 120);
j = j + 1;
}
print(sum);
Reference-এর python -B haat.py vm hot.haat ছাপে 143640, 1080, 215688 (লেখকের যন্ত্রে সত্যিকারের run). পাতার Python ব্লকগুলো চারটি সহায়ক module import করে, সবই আগের দুই পর্ব থেকে অপরিবর্তিত, একই নামে: haat_front.py আর haat_code.py (পর্ব ৫৮), haat_vm.py (পর্ব ৫৯-এর সহায়ক: পর্ব ৫৮-এর compiler হুবহু আর runtime-এর নিয়ম), আর stack_vm.py: পর্ব ৫৯-এর VM class, সেখানকার দুটি ব্লকের কোড হুবহু, শুধু পরীক্ষার লাইন বাদ। এই VM প্রতিটি opcode-এর জন্য একটি op_… method রাখে, তাই subclass একটি একটি করে opcode বদলাতে পারে; profiler আর JIT ঠিক তাই করবে।
পর্ব ৫৯-এর VM, stack_vm.py দেখুন (এই পাতার ব্লক এটি import করে)
# stack_vm.py — সহায়ক অংশ: পর্ব ৫৯-এর Haat VM, সেখানকার দুটি ব্লক (vm_loop.py, vm_calls.py)-এর কোড হুবহু,
# শুধু শেষের পরীক্ষার লাইন বাদ। VM-টি reference-এর vm.py-র মতো একই opcode, একই ফল আর একই runtime error দেয়।
from haat_vm import * # পর্ব ৫৮-এর compiler + disassemble, Frame, Closure, UNSET, arith, show
class VM:
def __init__(self, main, out=print):
self.main, self.out, self.stack, self.G = main, out, [], [UNSET] * len(main.global_names)
self.frames = [Frame(Closure(main, []), [])]
self.table = {n[3:]: getattr(self, n) for n in dir(self) if n.startswith("op_")}
def run(self):
while self.frames:
f = self.frames[-1]
name, arg = f.code.instrs[f.ip] # fetch
self.pos = f.code.positions[f.ip]; f.ip += 1
self.table.get(name, self.op_ARITH)(f, arg, name) # decode (table) + execute
def fail(self, msg): raise HaatRuntimeError(*self.pos, msg)
def glob(self, g):
if self.G[g] is UNSET: self.fail(f"'{self.main.global_names[g]}' is not initialized yet")
return self.G[g]
def op_CONST(self, f, k, _): self.stack.append(f.code.consts[k])
def op_LOAD_LOCAL(self, f, s, _): self.stack.append(f.slots[s])
def op_STORE_LOCAL(self, f, s, _): f.slots[s] = self.stack.pop()
def op_DEFINE_GLOBAL(self, f, g, _): self.G[g] = self.stack.pop()
def op_LOAD_GLOBAL(self, f, g, _): self.stack.append(self.glob(g))
def op_STORE_GLOBAL(self, f, g, _): self.glob(g); self.G[g] = self.stack.pop()
def op_ARITH(self, f, _, name):
b, a = self.stack.pop(), self.stack.pop(); self.stack.append(arith(ARITH[name], a, b, *self.pos))
def op_NEG(self, f, _, __): self.stack.append(wrap(-self.stack.pop()))
def op_NOT(self, f, _, __): self.stack.append(not self.stack.pop())
def op_JUMP(self, f, t, _): f.ip = t
def op_JUMP_IF_FALSE(self, f, t, _): f.ip = f.ip if self.stack.pop() else t
def op_PRINT(self, f, _, __): self.out(show(self.stack.pop()))
def op_POP(self, f, _, __): self.stack.pop()
def op_RETURN(self, f, _, __):
self.frames.pop() # ফলের মান stack-এ থেকে যায়
if not self.frames: self.stack.pop() # <main> শেষ
class Cell: # captured variable-এর এক-ঘরের বাক্স (পর্ব ১৭)
def __init__(self, value): self.value = value
class VM(VM): # আগের block-এর VM, বাকি সাতটি opcode যোগ
def op_MAKE_CELL(self, f, s, _): f.slots[s] = Cell(self.stack.pop())
def op_LOAD_CELL(self, f, s, _): self.stack.append(f.slots[s].value)
def op_STORE_CELL(self, f, s, _): f.slots[s].value = self.stack.pop()
def op_LOAD_FREE(self, f, i, _): self.stack.append(f.closure.cells[i].value)
def op_STORE_FREE(self, f, i, _): f.closure.cells[i].value = self.stack.pop()
def op_MAKE_CLOSURE(self, f, k, _):
code = f.code.consts[k] # captures: (নিজের slot?, index)
cells = [f.slots[i] if mine else f.closure.cells[i] for mine, i in code.captures]
self.stack.append(Closure(code, cells))
def op_CALL(self, f, n, _):
if len(self.frames) > MAX_CALL_DEPTH: self.fail("stack overflow")
args = self.stack[len(self.stack) - n:]; del self.stack[len(self.stack) - n:]
self.frames.append(Frame(self.stack.pop(), args)) # callee নিচে, argument ওপরেপ্রথম ব্লক পর্ব ৫৯-এর VM-কে ProfilingVM বানায়: run-এর loop-এ প্রতিটি নির্দেশ গোনা, আর op_JUMP_IF_FALSE ও op_ARITH-এ শাখার দিক আর ADD-এর type লেখা। তারপর hot.haat চালিয়ে profile পড়ে।
# ধাপ ১: পর্ব ৫৯-এর VM-এ একটি profiler — কোন function, কোন নির্দেশ গরম, শাখা কোন দিকে
from stack_vm import * # পর্ব ৫৯-এর VM, Frame, compile_src, arith, wrap … হুবহু
from collections import Counter
class ProfilingVM(VM): # পর্ব ৫৯-এর VM + তিন রকম গোনা; বাকি সব অপরিবর্তিত
def __init__(self, main, out=print):
super().__init__(main, out); self.hits, self.seen = Counter(), Counter()
def run(self): # পর্ব ৫৯-এর loop, শুধু প্রথম লাইনে গোনা বেশি
while self.frames:
f = self.frames[-1]; self.hits[f.code, f.ip] += 1
name, arg = f.code.instrs[f.ip]
self.pos = f.code.positions[f.ip]; f.ip += 1
self.table.get(name, self.op_ARITH)(f, arg, name)
def op_JUMP_IF_FALSE(self, f, t, name): # branch profile: True = jumped, False = fell through
self.seen[f.code, f.ip - 1, not self.stack[-1]] += 1; super().op_JUMP_IF_FALSE(f, t, name)
def op_ARITH(self, f, arg, name): # type feedback: what did this ADD get, int or str?
if name == "ADD": self.seen[f.code, f.ip - 1, type(self.stack[-2]).__name__] += 1
super().op_ARITH(f, arg, name)
def load(name): return compile_src(open(name, encoding="utf-8").read())
main = load("hot.haat"); vm = ProfilingVM(main); vm.run() # ছাপে 143640, 1080, 215688
total = sum(vm.hits.values())
for code in [main] + [c for c in main.consts if isinstance(c, Code)]:
n = sum(k for (c, ip), k in vm.hits.items() if c is code)
print(f"{code.name:8} calls {vm.hits[code, 0]:4} instructions {n:6} ({100 * n / total:.0f}%)")
price = main.consts[0]
print("hottest in price:", [(ip, price.instrs[ip][0], vm.hits[price, ip]) for ip in (0, 7, 8, 14)])
print("JUMP_IF_FALSE 14 at ip 7: jumped", vm.seen[price, 7, True], "fell through", vm.seen[price, 7, False])
print("ADD in <main> at ip 19 saw:", {t: vm.seen[main, 19, t] for t in ("int", "str")})আসল আউটপুট (ব্রাউজারের Python):
143640
1080
215688
<main> calls 1 instructions 8027 (66%)
price calls 401 instructions 4142 (34%)
hottest in price: [(0, 'LOAD_LOCAL', 401), (7, 'JUMP_IF_FALSE', 401), (8, 'LOAD_LOCAL', 33), (14, 'LOAD_LOCAL', 368)]
JUMP_IF_FALSE 14 at ip 7: jumped 368 fell through 33
ADD in <main> at ip 19 saw: {'int': 300, 'str': 0}
প্রথম চমক: price ৪০১ বার ডাকা হলেও মোট নির্দেশের মাত্র ৩৪% তার ভেতরে; ৬৬% <main>-এর দুটি while loop-এ, যারা একবারই “ডাকা” হয়। যে JIT শুধু call গোনে, সে এই hot spot কখনো দেখবে না; এ জন্য বাস্তব engine back edge-ও গোনে, আর চলমান loop-কে মাঝপথে compile-করা কোডে সরায় (অংশ ৪-এর OSR). দ্বিতীয়: price-এর ip 7-এর JUMP_IF_FALSE 14 ৩৬৮ বার লাফ দিয়েছে (ছোট অর্ডার, ছাড় নেই) আর ৩৩ বার পড়ে গেছে (ছাড়ের শাখা): একটি বড় অর্ডার আর মেশানো loop-এর ৩২টি। ip 8 তাই ৩৩ বার, ip 14 ৩৬৮ বার চলেছে। তৃতীয়: <main>-এর ip 19-এর ADD ৩০০ বার শুধু Int পেয়েছে; Haat-এ সেটিই প্রত্যাশিত।
৩ · খেলনা method JIT — bytecode থেকে চলার সময় কোড
এবার compiler. একটি method JIT একটি পুরো function-কে একক হিসেবে compile করে। আমাদের লক্ষ্য machine code নয়, Python source, যা exec একটি সাধারণ Python function বানাবে; কৌশল বাস্তব JIT-এর মতোই, শুধু শেষ ধাপটি ধার করা। তিনটি ধারণা লাগে।
এক, basic block. লাফের লক্ষ্য আর লাফের ঠিক পরের নির্দেশ থেকে একটি নতুন block শুরু হয়। price-এ block তিনটি: 0–7, 8–13, 14–15. প্রতিটি block হবে if pc == …:-এর একটি অংশ, আর লাফ হবে pc = t; continue.
দুই, symbolic stack. VM-এর operand stack চলার সময় মান রাখে; compiler-এর stack রাখে মান হিসাবের লেখা। LOAD_LOCAL 0 stack-এ রাখে লেখা v0, LOAD_LOCAL 1 রাখে v1, তারপর MUL দুটি নামিয়ে রাখে wrap(v0 * v1). STORE_LOCAL 2 সেটিকে একটি assignment হিসেবে লেখে: v2 = wrap(v0 * v1). চারটি নির্দেশ একটি লাইন। সতর্কতা: block-এর শেষে আর assignment-এর আগে জমে থাকা লেখাগুলো ক্রম রেখে নামে বসাতে হয় (s0 = …, কোডে spill), নইলে হিসাবের ক্রম (সিদ্ধান্ত ১২) বা error-এর সময় বদলাতে পারত (অনুশীলন ৪)।
তিন, profile থেকে guard. প্রতিটি JUMP_IF_FALSE-এ compiler profile দেখে। দুই দিকই দেখা গেলে সাধারণ শাখা। একটি দিক কখনো দেখা না গেলে সেই দিকের কোড বানানোই হয় না; সেখানে বসে একটি guard: শর্ত অনুমানের উল্টো হলে raise Deopt(ip, slots, stack). মানগুলো Haat-এর অর্থ মানে: wrap সিদ্ধান্ত ১৩-এর ৬৪-বিট wrap, arith('/', …) পর্ব ৫৯-এর VM-এর একই C-ধরনের ভাগ, আর শূন্য দিয়ে ভাগের error-এর line:col compile-এর সময়ই কোডে বসে যায় (সিদ্ধান্ত ২৬). খেলনাটি শুধু leaf function নেয়: cell, global, CALL বা PRINT পেলে None, অর্থাৎ VM-এই থাকুক; বাস্তব JIT-ও অসমর্থিত জায়গায় এভাবে পিছু হটে।
# ধাপ ২: খেলনা JIT — গরম function-এর bytecode থেকে Python source, profile দেখে অনুমানসহ
class Deopt(Exception): # a guard failed: continue in the VM at ip
def __init__(self, ip, slots, stack): self.ip, self.slots, self.stack = ip, slots, stack
def jit_source(code, seen): # None = not compiled (toy: leaf functions only)
v = [f"v{i}" for i in range(code.nlocals)]; blocks, depth, todo = {}, {0: 0}, [0]
starts = {a for op, a in code.instrs if op.startswith("JUMP")} | {i + 1 for i, (op, _) in enumerate(code.instrs) if op.startswith("JUMP")}
while todo: # only blocks the profile has reached
L = i = todo.pop()
st, out = [f"s{k}" for k in range(depth[L])], []; blocks[L] = out
def spill(): # stack values -> names s0, s1, ... (order kept)
for k, e in [(k, e) for k, e in enumerate(st) if e != f"s{k}"]: out.append(f"s{k} = {e}"); st[k] = f"s{k}"
def goto(t, test=""): spill(); depth[t] = len(st); todo.extend([t] * (t not in blocks)); out.append(f"{test}pc = {t}; continue")
def guard(test): out.append(f"if {test}: raise Deopt({i}, [{', '.join(v)}], [{', '.join(st + ['t'])}])")
while True:
op, a = code.instrs[i]; line, col = code.positions[i]
if op in ("CONST", "LOAD_LOCAL"): st.append(repr(code.consts[a]) if op == "CONST" else v[a])
elif op == "STORE_LOCAL": x = st.pop(); spill(); out.append(f"{v[a]} = {x}")
elif op in ("DIV", "MOD"): y, x = st.pop(), st.pop(); st.append(f"arith('{ARITH[op]}', {x}, {y}, {line}, {col})")
elif op in ARITH: # + - * wrap (decision 13), unless this ADD joined Str
y, x = st.pop(), st.pop(); e = f"{x} {ARITH[op]} {y}"
st.append(f"wrap({e})" if op in ("ADD", "SUB", "MUL") and not seen[code, i, "str"] else f"({e})")
elif op in ("NEG", "NOT"): st.append(f"wrap(-{st.pop()})" if op == "NEG" else f"(not {st.pop()})")
elif op == "RETURN": out.append(f"return {st.pop()}"); break
elif op == "JUMP": goto(a); break
elif op == "JUMP_IF_FALSE": # speculate on a direction the profile never saw
c = st.pop(); spill(); out.append(f"t = {c}"); jumped, fell = seen[code, i, True], seen[code, i, False]
if jumped and fell: goto(a, "if not t: ")
else: guard("not t" if fell else "t")
goto(i + 1 if fell else a); break
else: return None # cells, globals, CALL, PRINT: stay in the VM
i += 1
if i in starts: goto(i); break
head = [f"def jitted({', '.join(v[:code.arity])}):"] + [f" {' = '.join(v[code.arity:])} = None"] * (code.nlocals > code.arity)
return "\n".join(head + [" pc = 0", " while True:"] + [ln for L in sorted(blocks) for ln in [f" if pc == {L}:"] + [" " + s for s in blocks[L]]])
warm = ProfilingVM(load("warm.haat"), out=lambda s: None); warm.run(); print(jit_source(warm.main.consts[0], warm.seen))আসল আউটপুট (ব্রাউজারের Python):
def jitted(v0, v1):
v2 = None
pc = 0
while True:
if pc == 0:
v2 = wrap(v0 * v1)
t = (v2 >= 1000)
if t: raise Deopt(7, [v0, v1, v2], [t])
pc = 14; continue
if pc == 14:
return v2
warm.haat হলো hot.haat-এর প্রথম ১৩ লাইন: শুধু ছোট অর্ডার, তাই profile বলে ip 7-এর শাখা ৩০০ বারই লাফ দিয়েছে। ফলে ছাড়ের block (8–13) compile-ই হয়নি; তার জায়গায় একটি লাইন: if t: raise Deopt(7, [v0, v1, v2], [t]). লক্ষ করুন, guard ভাঙলে VM-কে আবার শুরু করতে হবে ঠিক ip 7-এ, শর্তের মান t stack-এ রেখে: তাহলে VM নিজেই JUMP_IF_FALSE চালাবে, profile-এ নতুন দিকটি লিখবে, আর সঠিক শাখায় যাবে। পুরো profile (৩৬৮ আর ৩৩) দিয়ে compile করলে guard থাকে না, তিনটি block-ই আসে, আর ছাড়ের block হয় return wrap(v2 - arith('/', v2, 10, 4, 33)), যেখানে 4:33 হলো hot.haat-এ /-এর অবস্থান।
খেয়াল করুন compiler কী করেনি: কোনো constant folding বা register allocation নেই। বাস্তব optimizing JIT এখানে মডিউল ১১ আর ১২-এর কৌশল চালায়: IR, SSA (পর্ব ৬৩), inlining (পর্ব ৬৭), register allocation (পর্ব ৭০). আমাদের লাভ শুধু fetch-decode আর ঠান্ডা কোড বাদ দেওয়া থেকে।
৪ · Speculation, guard আর deoptimization
JitVM হলো ProfilingVM-এর subclass, যা শুধু op_CALL বদলায়: call গোনে, ৫০তম call-এ compile করে (HOT = 50), আর compile-করা কোড থাকলে frame না খুলে সরাসরি Python function ডাকে। Deopt এলে তার slot দিয়ে Frame বানায়, ip বসায়, stack-এ মান রেখে VM-কে চলতে দেয়; তারপর কোড ফেলে দিয়ে আরও ৫০টি call পরে আবার compile করে, ততক্ষণে profile নতুন দিকটি দেখে ফেলবে।
2fn price(qty: Int, unit: Int) -> Int {3 let p = qty * unit;4 if p >= 1000 { … }5 return p;10sum = sum + price(i % 7 + 1, 120);14print(price(10, 120));17sum = sum + price(j % 12 + 1, 120);
| call | |
| কোন স্তর | |
| ip 7: লাফ / পড়া | |
| VM-এ price-এর নির্দেশ |
- প্রথম call. কোনো কোড compile হয়নি, তাই সাধারণ VM: নতুন frame, ১০টি নির্দেশ (0–7, তারপর 14, 15). Profile লেখে: ip 7-এর লাফ ১ বার।
- ৪৯তম call. এখনো VM. ৪৯টি call × ১০টি নির্দেশ = ৪৯০, আর শাখা ৪৯ বারই লাফ দিয়েছে, একবারও পড়েনি।
- ৫০তম call. গণনা সীমায় পৌঁছাল।
jit_sourceprofile (৪৯ / ০) দেখে guard-সহ কোড বানায়;execসেটিকে Python function করে, আর এই call-টিই সেই কোডে চলে: ফল120, VM-এ নতুন কোনো নির্দেশ নয়। - ৫১ থেকে ৩০০. ২৫০টি call সরাসরি Python function-এ। Profile ৪৯ / ০-তে থেমে আছে: compile-করা কোড আর গোনে না, কারণ গোনা নিজেই খরচ।
- ৩০১তম call, বড় অর্ডার.
10 * 120 = 1200, শর্ত সত্য, guard ভাঙে:Deopt(7, [10, 120, 1200], [True]). VM ip 7 থেকে চলে, শাখা এবার পড়ে যায় (profile ৪৯ / ১), ছাড়ের block-এর ৭টি নির্দেশ (7–13) চলে: ৪৯০ + ৭ = ৪৯৭, ফল1080. - ৩০২ থেকে ৩৫০. compile-করা কোড বাতিল, পরের compile ৩৫১তম call-এ (
hot_at = 301 + 50). মাঝের ৪৯টি call VM-এ, আর মেশানো অর্ডার দুই দিকেই profile বাড়ায়: ৮২ / ১৭. VM-এprice-এর মোট নির্দেশ এখন ১,০৫১. - ৩৫১ থেকে ৪০১. নতুন profile-এ দুই দিকই আছে, তাই এবার guard নেই, তিনটি block-ই compile. বাকি ৫১টি call আর কখনো VM-এ নামে না। মোট: শুধু VM-এ
price-এর ৪,১৪২টি নির্দেশ চলত, এখানে চলেছে ১,০৫১টি; ফল তিনটিই হুবহু এক।
এবার কোডে। নিচের ব্লক JitVM বানায়, hot.haat চালিয়ে log ছাপে, তারপর reference-এর পাঁচটি উদাহরণ ফাইল সাধারণ VM আর JitVM দুটিতে চালিয়ে মেলায়, আর .out ফাইলের সঙ্গেও, যা লেখকের যন্ত্রে reference-এর সত্যিকারের আউটপুট।
# ধাপ ৩: দুই স্তর — interpreter গোনে, গরম হলে JIT, অনুমান ভাঙলে deoptimization
class JitVM(ProfilingVM):
HOT = 50 # compile on the 50th call
def __init__(self, main, out=print):
super().__init__(main, out); self.calls, self.fast, self.hot_at, self.log = Counter(), {}, {}, []
def op_CALL(self, f, n, name):
closure = self.stack[-n - 1]; code = closure.code; self.calls[code] += 1
if code not in self.fast and self.calls[code] == self.hot_at.get(code, self.HOT):
src = jit_source(code, self.seen); ns = dict(wrap=wrap, arith=arith, Deopt=Deopt)
if src: exec(src, ns); self.fast[code] = ns["jitted"]
self.log.append(f"{code.name}: call {self.calls[code]}, " + ("compiled" if src else "not a leaf, stays interpreted"))
if not self.fast.get(code): return super().op_CALL(f, n, name) # পর্ব ৫৯-এর CALL
if len(self.frames) > MAX_CALL_DEPTH: self.fail("stack overflow") # same limit as the VM
args = self.stack[len(self.stack) - n:]; del self.stack[len(self.stack) - n - 1:]
try: self.stack.append(self.fast[code](*args))
except Deopt as d: # rebuild the frame the VM would have had
frame = Frame(closure, d.slots); frame.ip = d.ip
self.frames.append(frame); self.stack.extend(d.stack)
del self.fast[code]; self.hot_at[code] = self.calls[code] + self.HOT # profile again
self.log.append(f"{code.name}: call {self.calls[code]}, deopt at ip {d.ip}, slots {d.slots}")
def run_both(name): # same output from পর্ব ৫৯-এর VM and JitVM?
outs = []
for cls in (VM, JitVM):
lines, m = [], cls(load(name), out=lambda s: lines.append(s))
try: m.run()
except HaatRuntimeError as e: lines.append(str(e))
outs.append(lines)
return outs[0] == outs[1], outs[1], m
same, out, m = run_both("hot.haat")
print("hot.haat:", out, "same as VM:", same, "stack at end:", m.stack)
for event in m.log: print(" ", event)
for name in ("bazar", "counter", "nested", "recursion", "err_divzero"):
same, out, m = run_both(name + ".haat")
ref = open(name + ".out", encoding="utf-8").read().rstrip("\n") # real `haat.py vm` output
print(f"{name:12} JitVM == VM: {same} == reference: {chr(10).join(out) == ref} events: {m.log}")আসল আউটপুট (ব্রাউজারের Python):
hot.haat: ['143640', '1080', '215688'] same as VM: True stack at end: []
price: call 50, compiled
price: call 301, deopt at ip 7, slots [10, 120, 1200]
price: call 351, compiled
bazar JitVM == VM: True == reference: True events: []
counter JitVM == VM: True == reference: True events: []
nested JitVM == VM: True == reference: True events: []
recursion JitVM == VM: True == reference: True events: ['fib: call 50, not a leaf, stays interpreted']
err_divzero JitVM == VM: True == reference: True events: []
hot.haat-এর log stepper-এর সঙ্গে হুবহু মেলে, আর run শেষে operand stack খালি ([]), যা অনুশীলন ২-এ কাজে লাগবে। উদাহরণ ফাইলগুলোতে প্রায় কিছুই compile হয়নি, কারণ সেখানে কোনো function ৫০ বার ডাকা হয় না; একমাত্র fib (recursion.haat) ৫০তম call-এ পৌঁছায়, কিন্তু সে নিজেকে ডাকে, তাই leaf নয়, VM-এই থাকে। পাঁচটিতেই JitVM-এর আউটপুট VM আর reference-এর সঙ্গে এক, err_divzero.haat-এর runtime error-এর 3:18 অবস্থানসহ।
ছোট উদাহরণে JIT প্রায় ঘুমিয়ে থাকে, তাই আসল differential testing হয়েছে লেখকের যন্ত্রে (CPython 3.14.4): একটি generator seed 61 দিয়ে ৩,০০০টি এলোমেলো Haat program বানিয়েছে, প্রতিটিতে এক থেকে তিনটি leaf function (Int, Str বা Bool ফেরত দেওয়া), যা একটি loop-এ ৩, ৬০ বা ১২০ বার ডাকা হয়, শেষে নতুন ধরনের argument দিয়ে আরেকবার, যাতে guard ভাঙে। সব ৩,০০০টি reference-এর check পেরিয়েছে; ৪৮৮টি শূন্য দিয়ে ভাগের runtime error-এ শেষ হয়। ফল:
| সেটিং | reference-এর vm-এর সঙ্গে হুবহু এক | compile | deopt |
|---|---|---|---|
HOT = 50 | ৩,০০০ / ৩,০০০ | ৩,২৭৯ | ৩২৩ |
HOT = 2 (চাপ দেওয়ার জন্য) | ৩,০০০ / ৩,০০০ | ৬,৪৮৭ | ২,১৪৫ |
reference-এর ১০টি উদাহরণ আর এই পাতার ৪টি (hot, fee, অনুশীলন ৩-এর program, ১,০০০ স্তরের recursion-এর deep), দুই সেটিংয়ে | ২৮ / ২৮ | – | – |
HOT = 2-এ guard প্রায় সাতগুণ বেশি ভাঙে, তাই বিরল deopt-এর পথ অনেক বেশি পরীক্ষিত হয়। V8-এরও এই উদ্দেশ্যে পরীক্ষার flag আছে (Node 24-এর --v8-options-এ --always-turbofan আর --deopt-every-n-times). অনুশীলন ২-এর deopt-বাগ সাধারণ সেটিংয়ে ৩,০০০-এর মাত্র ২৩টিতে ধরা পড়ে, চাপ দেওয়া সেটিংয়ে ৭২১টিতে।
Deoptimization কেন সঠিক — একটি invariant
“guard ভাঙলে VM-এ ফেরা” কথাটি সহজ, কিন্তু সঠিক হতে হলে ফেরার মুহূর্তে VM-কে ঠিক সেই অবস্থায় পেতে হবে, যে অবস্থায় সে নিজে চালালে থাকত। VM-এর অবস্থা লিখি σ = ⟨ip, S, ρ⟩: ip পরের নির্দেশ, S operand stack (নিচ থেকে ওপরে), ρ slot-গুলো। Compile-করা কোডের অবস্থা হলো Python variable-এর মান E. Compiler-এর symbolic stack st একটি লেখার তালিকা; ⟦st⟧E মানে E-তে সেই লেখাগুলোর মান। Guard-এর নিয়মটি একটি inference rule হিসেবে:
পড়ুন: “slot-এর নাম আর symbolic stack যদি VM-এর slot আর stack-এর সমান মান ধরে, আর শর্ত profile-এ না-দেখা দিকে যায়, তবে Deopt VM-কে দেয় ip i-তে, stack-এর ওপরে শর্তের মান নিয়ে”। ওপরের প্রথম দুটি শর্তই invariant I, যা compile-করা কোডের প্রতিটি লাইনের পরে সত্য থাকতে হবে।
প্রমাণের রূপরেখা (একটি block-এর নির্দেশের সংখ্যার ওপর induction; VM-ও ঠিক এই নির্দেশগুলো চালাত):
- ভিত্তি. Function-এর শুরুতে VM-এর ρ = argument, বাকি slot
None, S খালি; generated কোড parameter-এর নামে argument পায়, বাকিv=None, st খালি। Block-এর শুরুতে st = [s0 … sd−1], আর আগের block শেষেspillঠিক এই নামে stack-এর মান রেখে গেছে, তাই I সত্য। CONST,LOAD_LOCAL, arithmetic, তুলনা. VM S-এ একটি মান রাখে; compiler st-এ সেই মানের লেখা রাখে (repr(c),va, বাwrap(x * y)যেখানে x, y আগের লেখা)। লেখাগুলো একই function দিয়ে মান পায় (wrap,arith: VM যা ব্যবহার করে, সেই function-ই), তাই ⟦st⟧E = S থাকে।STORE_LOCAL a. আগে বাকি stackspillহয়, তাই নিচের কোনো লেখা পুরোনো va-এর ওপর নির্ভর করে না; তারপরva = x. VM-এ ρ(a) = মান(x). দুই শর্তই টেকে।- Guard.
t = cলেখার আগে spill, তাই শর্ত হিসাবের সময়ের আগের সব error আগে ঘটে, VM-এর ক্রমেই। Guard ভাঙলে Deopt নিয়মের তিনটি শর্ত পূরণ, তাই VM ⟨i, S · E(t), ρ⟩ থেকে চলে, যা ঠিক VM নিজে i-তে পৌঁছে পেত; সেখান থেকে বাকি চলা সংজ্ঞা অনুযায়ী VM-এর চলা। Guard না ভাঙলে t সেই দিক যা compile হয়েছে, আরpcসেই block-এ যায় যেখানে VM লাফ দিত। - উপসংহার. প্রতিটি পথে generated কোড হয় VM-এর একই ফল ফেরত দেয়, নয় VM-কে এমন অবস্থায় দেয় যেখান থেকে VM নিজে চললে একই ফল দিত; তাই আউটপুট আর runtime error দুটিই অভিন্ন। ∎
এই রূপরেখা leaf function-এর, যেখানে Deopt-এ একটি frame গড়লেই চলে। বাস্তব engine inlining করে, তাই একটি optimize-করা frame থেকে কয়েকটি interpreter frame গড়তে হয়; এ জন্য প্রতিটি guard-এর পাশে একটি “deopt metadata” টেবিল থাকে: কোন register-এ কোন slot-এর মান। আমাদের [v0, v1, v2] সেই টেবিলের সবচেয়ে ছোট রূপ।
Stepper-এ ৩০১তম call-টি এক ঝলকে দেখেছেন; নিচে সেটি নির্দেশ ধরে, compile-করা কোড থেকে VM-এ ফেরা পর্যন্ত:
av2 = wrap(v0 * v1)bt = (v2 >= 1000)cif t: raise Deopt(7, …)7JUMP_IF_FALSE 148LOAD_LOCAL 29LOAD_LOCAL 210CONST 1 ; 1011DIV12SUB13RETURN
| কে চালাচ্ছে | |
| slot / নাম | |
| operand stack |
- Compile-করা কোড.
v0 = 10,v1 = 120;wrap(10 * 120)=1200. Python-এর একটি সাধারণ assignment, VM-এর চারটি নির্দেশের (0–3) সমান। - শর্ত.
1200 >= 1000সত্য। Profile বলেছিল এই দিকটি কখনো আসেনি। - Guard ভাঙে.
Deopt(7, [10, 120, 1200], [True]).JitVM.op_CALLসেটি ধরে,Frame(closure, [10, 120, 1200])বানায়,ip = 7বসায়, stack-এTrueরাখে।<main>CALL-এর আগে callee আর argument তুলে নিয়েছিল, তাই নিচে আর কিছু নেই। JUMP_IF_FALSE 14. VM নিজে চালায়:Trueনামায়, লাফ দেয় না, আর profile-এ লেখে “পড়ে গেল”: এই এক লাইনের জন্যই Deopt ip 8-এ নয়, ip 7-এ ফেরে।- দুটি
LOAD_LOCAL 2.pদুবার: stack[1200, 1200]. মান এসেছে Deopt-এর slot তালিকা থেকে; সেখানেv2না থাকলে এখানেNoneপড়ত। CONST 1. consts[1] =10: stack[1200, 1200, 10].DIV, তারপরSUB.1200 / 10=120, তারপর1200 - 120=1080.RETURN. Frame বন্ধ,1080stack-এ থাকে;<main>-এরPRINTছাপে1080, reference-এর দ্বিতীয় লাইনের সঙ্গে এক।
On-stack replacement — চলমান loop বদলানো
অংশ ২-এর profile-এ সময়ের ৬৬% ছিল <main>-এর loop-এ, যা একবারই ডাকা হয়; call গুনে compile করলে সেখানে লাভ নেই। On-stack replacement (OSR) এর সমাধান: loop-এর back edge গোনা, সীমা পেরোলে loop compile করা, আর চলমান interpreter frame থেকে slot আর stack তুলে মাঝপথেই compile-করা কোডে লাফ দেওয়া। এটি deoptimization-এর আয়না: deopt compile-করা অবস্থা থেকে VM-এর অবস্থা গড়ে, OSR উল্টোটা। অংশ ৬-এর V8 trace-এ নামহীন top-level script ঠিক এভাবে (target MAGLEV) OSR হয়েছে।
৫ · Tracing JIT — একটি পথ রেকর্ড করা
Method JIT-এর একক function; tracing JIT-এর একক একটি পথ। ধারণাটি: গরম loop খুঁজে পেলে interpreter পরের ঘোরায় যা যা আসলে চালায়, সেগুলো একটি সরল তালিকায় লিখে রাখে (trace). শাখা এলে trace শুধু নেওয়া দিকটি রাখে, আর সেখানে একটি guard বসায়; guard ভাঙলে side exit, interpreter-এ ফেরা। Loop-এর শুরুতে ফিরলে trace বন্ধ আর compile. Trace-এ শাখা নেই, তাই optimize করা সহজ; আর trace ডাকা function-এর ভেতরেও ঢোকে, যা আপনাআপনি inlining. Bazar.haat-এর loop দিয়ে দেখি; সীমা ধরা হলো ২টি back edge (খেলনা সংখ্যা):
14while total < 5000 { total = total + 1250; rounds = rounds + 1;}15print(total);
| total, rounds | |
| trace |
- গরম হওয়া. প্রথম দুই ঘোরা VM-এ; প্রতিবার ip 34-এর
JUMP 22back edge গোনা হয়। দ্বিতীয়বারের পর total 2500, rounds 2: loop গরম, পরের ঘোরা রেকর্ড হবে। - শর্ত রেকর্ড. ঘোরা ৩: interpreter স্বাভাবিকভাবে চালায়, পাশাপাশি লেখে।
2500 < 5000সত্য, তাইJUMP_IF_FALSE 35-এর জায়গায় trace-এGUARD_TRUE: “সত্য না হলে 35-এ বেরিয়ে যাওয়া”। মিথ্যা শাখার কোনো কোড trace-এ নেই। - প্রথম assignment.
2500 + 1250 = 3750; চারটি নির্দেশ trace-এ। এগুলোর পরে total = 3750. - দ্বিতীয় assignment. rounds 2 থেকে 3; আরও চারটি নির্দেশ।
- Loop বন্ধ.
JUMP 22trace-এর শুরুতেই ফেরে, তাই trace একটি বন্ধ loop (T12 মানে T0-তে ফেরা)। এবার compile; join বিন্দু নেই, তাই optimizer-এর কাজ একটি সরল লাইনে। - Trace-এ চলা. ঘোরা ৪ পুরোটাই compile-করা trace-এ: guard পেরোয় (
3750 < 5000), total 5000, rounds 4. VM-এর একটি নির্দেশও চলেনি। - Side exit. শর্ত আবার:
5000 < 5000মিথ্যা, guard ভাঙে। Trace থেকে বেরিয়ে VM ip 35-এ চলে, যেখানেprint(total): ছাপা হয়5000, তারপর3. মানগুলো VM-এর সত্যিকারের run-এ প্রতিটি নির্দেশের আগের stack দেখে মেলানো।
দুর্বলতাও এখানে দেখা যায়: loop-এর ভেতরে দুই দিকেই প্রায় সমান নেওয়া একটি if থাকলে trace একটি দিকই জানে; অন্য দিকে বারবার side exit, তারপর আরেকটি trace, আর শাখা বাড়লে trace-এর সংখ্যা দ্রুত বাড়ে। Method JIT পুরো control flow graph দেখে, তাই এমন কোডে প্রায়ই স্থির (ভাবনার প্রশ্ন ২)।
বাস্তবে tracing JIT-এর তিনটি পরিচিত উদাহরণ: LuaJIT (Mike Pall; version 2-এর trace compiler), PyPy, আর CPython-এর নতুন পরীক্ষামূলক JIT. PyPy-র বৈশিষ্ট্য meta-tracing (Bolz, Cuni, Fijałkowski আর Rigo, ২০০৯): JIT ব্যবহারকারীর program নয়, interpreter-এর নিজের loop trace করে (পর্ব ১২-এর “আরও গভীরে”)। CPython 3.13-এর JIT (PEP 744) গরম কোডের bytecode-কে ছোট “micro-op”-এর trace-এ ভাঙে, তারপর copy-and-patch: প্রতিটি micro-op-এর machine code-এর ছাঁচ CPython build করার সময়ই LLVM দিয়ে তৈরি থাকে, চলার সময় শুধু ছাঁচ কপি করে ঠিকানা আর ধ্রুবক বসানো হয় (কৌশলটি Xu আর Kjolstad-এর ২০২১ সালের প্রবন্ধ থেকে)। CPython-এর ভেতরের বিবরণ প্রতি version-এ বদলাচ্ছে, তাই দাবির আগে সেই version-এর উৎস দেখুন।
৬ · বাস্তবের JIT — V8, CPython 3.14 আর PyPy, নিজের যন্ত্রে
V8: Ignition-এর bytecode, trace-opt আর trace-deopt
একই price JavaScript-এ (Math.trunc দিয়ে Haat-এর মতো শূন্যের দিকে ভাগ), দুই লাখ ছোট অর্ডার, তারপর একটি বড়, তারপর string argument. প্রথমে V8-এর interpreter Ignition-এর bytecode, সত্যিকারের run (Node 24.15.0; ঠিকানার কলাম আর কিছু লাইন ছাঁটা):
$ node --print-bytecode --print-bytecode-filter=price v8demo.js
[generated bytecode for function: price (0x… <SharedFunctionInfo price>)]
Bytecode length: 42
Parameter count 3
Register count 5
@ 0 : 0b 04 Ldar a1
@ 2 : 41 03 00 Mul a0, [0]
@ 5 : ce Star0
@ 6 : 00 0d e8 03 LdaSmi.Wide [1000]
@ 10 : 78 f9 01 TestGreaterThanOrEqual r0, [1]
@ 13 : a3 1a JumpIfFalse [26] (… @ 39)
@ 15 : 23 00 03 LdaGlobal [0], [3]
@ 18 : cb Star3
@ 19 : 33 f6 01 05 GetNamedProperty r3, [1], [5]
…
@ 38 : b3 Return
@ 39 : 0b f9 Ldar r0
@ 41 : b3 Return
Haat-এর bytecode-এর সঙ্গে তুলনা করুন: আকার আর শাখা প্রায় একই, কিন্তু Ignition stack machine নয়। প্রায় প্রতিটি নির্দেশ একটি লুকানো accumulator-এ কাজ করে (Ldar = register থেকে accumulator-এ, Star0 = accumulator থেকে r0-এ), আর Mul a0, [0]-এর [0] হলো একটি feedback ঘরের নম্বর: এই গুণে কোন type এল, profiler এখানে লেখে। এবার tier আর deopt দেখি। Optimization এমনিতে একটি আলাদা thread-এ চলে, তাই log-এর ক্রম run-ভেদে বদলায়; ক্রম স্থির করতে --no-concurrent-recompilation দেওয়া হলো (তিনবার চালিয়ে তিনবারই একই ক্রম; ঠিকানা ছাঁটা):
$ node --no-concurrent-recompilation --trace-opt --trace-deopt v8demo.js
sum 95999280
big 1080
text 936
[marking <JSFunction price> for optimization to MAGLEV, ConcurrencyMode::kConcurrent, reason: hot and stable]
[compiling method <JSFunction price> (target MAGLEV), mode: ConcurrencyMode::kSynchronous]
[completed compiling <JSFunction price> (target MAGLEV) - took 0.000, 0.046, 0.001 ms]
[marking <JSFunction > for optimization to MAGLEV, ConcurrencyMode::kConcurrent, reason: hot and stable]
[marking <JSFunction price> for optimization to TURBOFAN_JS, ConcurrencyMode::kConcurrent, reason: hot and stable]
[compiling method <JSFunction price> (target TURBOFAN_JS), mode: ConcurrencyMode::kSynchronous]
[completed compiling <JSFunction price> (target TURBOFAN_JS) - took 0.007, 0.805, 0.005 ms]
[compiling method <JSFunction > (target MAGLEV) OSR, mode: ConcurrencyMode::kSynchronous]
[completed compiling <JSFunction > (target MAGLEV) OSR - took 0.000, 0.117, 0.001 ms]
[bailout (kind: deopt-eager, reason: Insufficient type feedback for binary operation): begin. deoptimizing <JSFunction >, <Code MAGLEV>, opt id 4, bytecode offset 72, …]
[bailout (kind: deopt-eager, reason: Insufficient type feedback for generic named access): begin. deoptimizing <JSFunction price>, <Code TURBOFAN_JS>, opt id 3, bytecode offset 19, …]
প্রথম তিন লাইন program-এর আউটপুট (V8-এর log আলাদা buffer-এ যায়, তাই ফাইলে ক্রম এমন)। price “hot and stable” হয়ে আগে Maglev-এ, পরে TurboFan-এ উঠেছে: দুই ধাপের tiering. নামহীন <JSFunction > হলো top-level script, যার loop চলমান অবস্থায় OSR হয়েছে। শেষ লাইনটি আমাদের Deopt(7, …)-এর আত্মীয়: TurboFan কোড bytecode offset 19-এ deopt করেছে, যা listing-এ GetNamedProperty, অর্থাৎ Math.trunc পড়া। ছাড়ের শাখা দুই লাখ call-এ একবারও চলেনি, তাই সেখানে feedback নেই (“Insufficient type feedback”), আর TurboFan সেখানে কোড না বানিয়ে deopt বসিয়েছিল; big 1080-এর call সেটি ভেঙেছে। Loop-এর deopt (offset 72)-ও একই কারণে: loop-এর পরের "sum " + sum আগে কখনো চলেনি।
CPython 3.14: পরীক্ষামূলক JIT, চালু করে দেখা
পর্ব ০৪-এ বলা হয়েছে, CPython 3.14-এ JIT পরীক্ষামূলক আর ডিফল্টে বন্ধ। Python 3.14-এর “What's New” অনুযায়ী Windows আর macOS-এর অফিসিয়াল binary-তে এটি build করা থাকে, আর PYTHON_JIT=1 environment variable দিয়ে চালু হয়; সেখানেই লেখা, কাজভেদে প্রভাব সাধারণত “১০% ধীর থেকে ২০% দ্রুত”। লেখকের যন্ত্রের python.org-এর CPython 3.14.4-এ সত্যিকারের run, sys._jit দিয়ে:
$ python -c "import sys; j = sys._jit; print(j.is_available(), j.is_enabled(), j.is_active())"
True False False
$ PYTHON_JIT=1 python -c "import sys; j = sys._jit; print(j.is_available(), j.is_enabled(), j.is_active())"
True True False
$ PYTHON_JIT=1 python -B cpy_active.py # loop-এর ভেতরে প্রতি ঘোরায় sys._jit.is_active()
round 0 is_active() True in 95904 of 100000 iterations
round 1 is_active() True in 95904 of 100000 iterations
round 2 is_active() True in 95904 of 100000 iterations
is_available() বলে এই binary-তে JIT আছে, is_enabled() বলে এই process-এ চালু, আর is_active() বলে এই মুহূর্তে সবচেয়ে ওপরের Python frame JIT-এর বানানো কোডে চলছে কি না। Top level-এ সেটি False; কিন্তু loop-এর ভেতরে প্রতিটি ডাকে প্রথম ৪,০৯৬টি ঘোরায় False, বাকি ৯৫,৯০৪টিতে True: সেই warm-up আর hotness counter, চোখের সামনে। JIT বন্ধ রেখে একটিতেও True আসেনি। ৪,০৯৬ সংখ্যাটি এই build-এর ভেতরের সীমা বলে মনে হয়; version-ভেদে বদলাতে পারে, মুখস্থ করবেন না।
খেলনা JIT, তিনটি Python-এ: সময়
শেষে পর্ব ৫৯-এর VM, ProfilingVM আর JitVM একই bulk.haat-এ (hot.haat-এর মতো price, ২০,০০০টি অর্ডার, ফল 14758416, reference-এর সঙ্গে এক), তিনটি Python বাস্তবায়নে। প্রতিটি সংখ্যা পাঁচ run-এর median, পুরো পরীক্ষা তিনবার চালিয়ে কাছাকাছি ফল; এক যন্ত্রের উদাহরণ মাত্র (Windows, x86-64):
| কে চালাল | VM | ProfilingVM | JitVM |
|---|---|---|---|
| CPython 3.14.4, JIT বন্ধ (ডিফল্ট) | ০.২২ s | ০.৩৮–০.৪০ s | ০.২৫–০.২৭ s |
CPython 3.14.4, PYTHON_JIT=1 | ০.২০–০.২১ s | ০.৩২–০.৩৬ s | ০.২৬ s |
| PyPy 7.3.23 (Python 3.11.15) | ০.০২৫ s | ০.০৯৩ s | ০.০৭৫ s |
সংখ্যাগুলো একটি অস্বস্তিকর সত্য বলে। এক, profiling-এর দাম: প্রতিটি নির্দেশে Counter-এ গোনা VM-কে প্রায় ১.৭ গুণ ধীর করে। JitVM সেই profiling VM-এর চেয়ে প্রায় দেড় গুণ দ্রুত (VM-এ চলা নির্দেশ ৬,২৬,৬৭০ থেকে ৪,০০,৫৬৮), কিন্তু সাধারণ VM-কে হারায়নি, কারণ <main>-এর loop (OSR নেই) গোনা-সহ চলে। বাস্তব engine তাই গোনে খুব সস্তায় আর compile-করা কোডে গোনা বন্ধ রাখে। দুই, CPython-এর পরীক্ষামূলক JIT এখানে সামান্য সাহায্য করেছে (VM প্রায় ৫–১০% দ্রুত); অথচ এই পাতার আগের খসড়ার if/elif-শিকলের VM-এ, একই যন্ত্রে, একই flag সময় প্রায় ৩০% বাড়িয়েছিল: “What's New”-এর কথামতোই, কাজভেদে দুই দিকেই। তিন, PyPy একই Python কোড বদল ছাড়াই প্রায় নয় গুণ দ্রুত চালিয়েছে, আর সেখানে খেলনা JIT উল্টো ক্ষতি করেছে, কারণ PyPy আগেই VM-এর loop-কে machine code বানিয়েছে, আর আমাদের গোনার dictionary-ই তখন প্রধান খরচ।
আরও গভীরে: “JIT” শব্দটির আগেই ধারণাটি ছিল। Ken Thompson ১৯৬৮ সালে regular expression-কে চলার সময় সরাসরি IBM 7094-এর machine code-এ অনুবাদ করে খুঁজতেন (তত্ত্বের দিক গণনার তত্ত্বের পর্ব ২২-এ)। Smalltalk-80-এর Deutsch আর Schiffman (১৯৮৪) method-কে চলার সময় native code-এ অনুবাদ করে cache রাখতেন, আর inline cache-এর ধারণাও সেখান থেকে। Self ভাষার দল (Chambers, Ungar, Hölzle; ১৯৮৯–১৯৯৪) type feedback, polymorphic inline cache আর deoptimization-কে একত্র করে, আর সেই অভিজ্ঞতা থেকে HotSpot JVM (১৯৯৯) আর পরে V8 (২০০৮) আসে। John Aycock-এর ২০০৩ সালের সমীক্ষা “A Brief History of Just-In-Time” এই ধারা LISP পর্যন্ত টেনে নেয়।
৭ · Machine code পর্যন্ত — Haat bytecode থেকে WebAssembly
খেলনা JIT Python source বানায়; সত্যিকারের JIT বানায় machine code, executable মেমরিতে লেখে, আর সেখানে লাফ দেয়। Browser-এ নিজের machine code লেখা যায় না, কিন্তু নিরাপদ বিকল্প আছে: WebAssembly-এর byte বানিয়ে WebAssembly.instantiate-কে দেওয়া, যা যাচাই করে machine code বানায়। নিচের ব্লক তাই একটি JIT-এর সামনের অর্ধেক, browser-এর Wasm compiler পেছনের অর্ধেক। Haat-এর পুরো Wasm back end আসবে পর্ব ৭৩-এ (WebAssembly target); এখানে শুধু একটি গরম function, price.
Haat bytecode আর Wasm দুটিই stack machine, তাই অনুবাদ প্রায় এক-এক: LOAD_LOCAL → local.get, MUL → i64.mul, GE → i64.ge_s. দুটি জায়গায় সাবধান হতে হয়। প্রথম, Wasm-এ যেকোনো জায়গায় লাফ নেই, আছে শুধু গঠিত if … end আর block/loop; তাই খেলনা শুধু “then-শাখা RETURN-এ শেষ” আকারের JUMP_IF_FALSE নেয়, ঠিক price-এর আকার। দ্বিতীয়, অর্থ। i64.mul আর i64.sub ৬৪-বিটে wrap করে, সিদ্ধান্ত ১৩-এর মতোই; কিন্তু i64.div_s শূন্য দিয়ে ভাগে আর INT_MIN / -1-এ trap করে, যেখানে Haat প্রথমটিতে অবস্থানসহ error দেয় আর দ্বিতীয়টিতে wrap করে। তাই খেলনা শুধু 0 বা −1 নয় এমন ধ্রুবক ভাজকের DIV নেয়, বাকিগুলো VM-এই থাকে: এটি speculation নয়, static প্রমাণ, তাই guard লাগে না।
// গরম Haat function-এর bytecode থেকে সত্যিকারের WebAssembly; browser-এর engine সেটিকে machine code বানাবে
const price = { name: "price", arity: 2, nlocals: 3, consts: [1000n, 10n], instrs: [ // `haat.py dis`-এর হুবহু
["LOAD_LOCAL", 0], ["LOAD_LOCAL", 1], ["MUL"], ["STORE_LOCAL", 2], ["LOAD_LOCAL", 2], ["CONST", 0], ["GE"],
["JUMP_IF_FALSE", 14], ["LOAD_LOCAL", 2], ["LOAD_LOCAL", 2], ["CONST", 1], ["DIV"], ["SUB"], ["RETURN"],
["LOAD_LOCAL", 2], ["RETURN"]] };
const OP = { ADD: 0x7c, SUB: 0x7d, MUL: 0x7e, DIV: 0x7f, MOD: 0x81, EQ: 0x51, NE: 0x52, // i64.add … i64.rem_s,
LT: 0x53, GT: 0x55, LE: 0x57, GE: 0x59, RETURN: 0x0f }; // i64.lt_s …, return
const sleb = (v) => { const b = []; for (;;) { const x = Number(v & 0x7fn); v >>= 7n; // signed LEB128
if ((v === 0n && !(x & 0x40)) || (v === -1n && (x & 0x40))) return [...b, x]; b.push(x | 0x80); } };
function toWasm(code) {
const body = [0x01, code.nlocals - code.arity, 0x7e], ends = []; // extra locals are i64; open `if`s
code.instrs.forEach(([op, a], i) => {
while (ends.at(-1) === i) { body.push(0x0b); ends.pop(); } // close an `if` here
if (op === "LOAD_LOCAL" || op === "STORE_LOCAL") body.push(op === "LOAD_LOCAL" ? 0x20 : 0x21, a);
else if (op === "CONST") body.push(0x42, ...sleb(code.consts[a]));
else if (op === "JUMP_IF_FALSE") { // only the "if c { … return }" shape
if (code.instrs[a - 1][0] !== "RETURN") throw new Error("not compiled: jump shape");
body.push(0x04, 0x40); ends.push(a);
} else if (op in OP) { // Wasm traps on /0 and MIN / -1; Haat: error on /0, wrap on MIN / -1
const [prev, k] = code.instrs[i - 1], safe = prev === "CONST" && ![0n, -1n].includes(code.consts[k]);
if ((op === "DIV" || op === "MOD") && !safe) throw new Error("not compiled: divisor"); body.push(OP[op]);
} else throw new Error("not compiled: " + op);
});
const name = [...code.name].map((c) => c.charCodeAt(0)), sec = (id, b) => [id, b.length, ...b]; // sizes < 128
return new Uint8Array([0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, ...sec(1, [1, 0x60, code.arity,
...Array(code.arity).fill(0x7e), 1, 0x7e]), ...sec(3, [1, 0]), ...sec(7, [1, name.length, ...name, 0x00, 0]),
...sec(10, [1, body.length + 1, ...body, 0x0b])]); // (i64, i64) -> i64, export "price"
}
const bytes = toWasm(price); console.log(bytes.length, "bytes, valid:", WebAssembly.validate(bytes));
console.log([...bytes.slice(-29)].map((b) => b.toString(16).padStart(2, "0")).join(" "));
WebAssembly.instantiate(bytes).then(({ instance }) => {
for (const [q, u] of [[2n, 520n], [7n, 120n], [10n, 120n], [3037000500n, 3037000500n], [-5n, 300n]])
console.log(`price(${q}, ${u}) = ${instance.exports.price(q, u)}`);
});আসল আউটপুট (ব্রাউজারের JavaScript):
68 bytes, valid: true
20 00 20 01 7e 21 02 20 02 42 e8 07 59 04 40 20 02 20 02 42 0a 7f 7d 0f 0b 20 02 0f 0b
price(2, 520) = 936
price(7, 120) = 840
price(10, 120) = 1080
price(3037000500, 3037000500) = -9223372036709301616
price(-5, 300) = -1500
৬৮ byte-এর একটি বৈধ module. দ্বিতীয় লাইন শেষের ২৯টি byte, অর্থাৎ price-এর শরীর: 20 00 20 01 7e 21 02 = local.get 0; local.get 1; i64.mul; local.set 2, যা Haat-এর 0–3; 42 e8 07 = i64.const 1000 (signed LEB128-এ ১,০০০), 59 = i64.ge_s, 04 40 = if; তারপর ছাড়ের হিসাব, 0f = return, 0b = end. পাঁচটি ফলই reference-এর haat.py vm-এর সঙ্গে এক (লেখকের যন্ত্রে একই পাঁচটি call-এর সত্যিকারের run): 936, 840, 1080, wrap হওয়া -9223372036709301616 (3037000500² ৬৪-বিটে ধরে না), আর -1500. Node 24-এও একই ছয় লাইন এসেছে।
একটি নিরাপত্তার কথা। Machine code লিখে চালাতে মেমরি লেখার আর চালানোর যোগ্য হতে হয়, আর JIT-এর একটি বাগ (যেমন ভুলে বাদ পড়া guard) type-এর নিরাপত্তা ভাঙতে পারে। তাই engine-গুলো লেখা আর চালানোর অনুমতি একসঙ্গে না রাখার (W^X) চেষ্টা করে, আর V8-এর --jitless কোনো executable মেমরিই তৈরি করে না, গতির দামে। JIT-এর বাগ খোঁজার প্রধান হাতিয়ার এই পর্বের কৌশলই: JIT চালু আর বন্ধ রেখে এলোমেলো program-এর ফল মেলানো (Software Testing & QA-র পর্ব ৬০)।
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন সাধারণ:
- JIT আর AOT-এর মূল পার্থক্য? JIT চলার সময় compile করে, তাই profile দেখে অনুমান করতে পারে; দাম warm-up, মেমরি আর জটিলতা।
- Deoptimization কী আর কেন লাগে? অনুমানের guard ভাঙলে compile-করা কোড থেকে interpreter-এর সমান অবস্থা গড়ে সেখানে ফেরা; এটি আছে বলেই JIT সাহসী অনুমান করতে পারে।
- OSR কী? চলমান loop-কে মাঝপথে compile-করা কোডে সরানো (আর উল্টোটা deopt-এ); না থাকলে একবার ডাকা দীর্ঘ loop কখনো দ্রুত হয় না।
- Method JIT বনাম tracing JIT? প্রথমটি পুরো function-এর control flow graph compile করে; দ্বিতীয়টি একটি গরম loop-এর আসলে চলা পথ, শাখায় guard রেখে।
৮ · AI-এর যুগে JIT নিয়ে কাজ
JIT-এর তথ্য engine আর version-ভেদে দ্রুত বদলায়, আর AI assistant প্রায়ই পুরোনো বা বানানো খুঁটিনাটি আত্মবিশ্বাসের সঙ্গে মেশায়। বারবার দেখা ভুল:
| AI-এর ভুল | কীভাবে ধরবেন |
|---|---|
বানানো flag বা স্তর, যেমন “python -O JIT চালু করে”, বা V8-এর পুরোনো স্তরের নাম (Crankshaft) এখনকার বলে | node --v8-options, CPython-এর “What's New”, sys._jit দিয়ে নিজে দেখা |
| নির্দিষ্ট threshold (“ঠিক ১০,০০০ call-এ compile”) সব engine-এর জন্য | সেই engine আর version-এ --trace-opt চালিয়ে দেখা |
| “JIT চালু করলে সবসময় দ্রুত” | warm-up আলাদা রেখে নিজের কাজে মেপে দেখা; এই পাতার একটি CPython run-এ উল্টো ফল এসেছে |
| JIT লিখতে গিয়ে ভাষার অর্থ বদলানো: wrap বাদ, C-র বদলে host-এর ভাগ, Wasm-এর trap-কে Haat-এর error ধরে নেওয়া | VM আর JIT-এর differential test, সীমার মান (INT_MIN / -1, শূন্য দিয়ে ভাগ) দিয়ে |
| Deopt-এ ভুল ip বা অর্ধেক অবস্থা ফেরানো, যার আউটপুট প্রায়ই ঠিক দেখায় | শেষে stack খালি কি না যাচাই, আর কম threshold দিয়ে চাপ দেওয়া test |
| “Python interpreted, তাই JIT নেই” বা উল্টো “CPython-এ এখন পূর্ণ JIT” | বাস্তবায়ন আর version বলে প্রশ্ন করা (CPython 3.14, PyPy 7.3) |
AI-কে কাজে লাগানোর ভালো উপায়: engine আর version নিজে বলে দিন, আর প্রতিটি দাবির পাশে যাচাইয়ের command চান, যাতে নিজের যন্ত্রে চালিয়ে মেলাতে পারেন।
AI-এর লেখা JIT বা JIT-এর ব্যাখ্যা হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১Self ভাষার একটি গবেষণা দল কীভাবে আজকের প্রায় সব JIT-এর মূল কৌশলগুলো (type feedback, inline cache, deoptimization) একসঙ্গে আবিষ্কার করল, আর সেগুলো Java ও JavaScript-এ কীভাবে পৌঁছাল?
Self একটি prototype-ভিত্তিক, সম্পূর্ণ dynamic ভাষা, যার নকশা করেন David Ungar আর Randall Smith (১৯৮৬–৮৭)। এতে কোনো class নেই, প্রতিটি কাজ একটি message, এমনকি variable পড়াও। এমন ভাষা দ্রুত চালানো অসম্ভব মনে হতো। Stanford-এ Craig Chambers, Ungar আর পরে Urs Hölzle-এর কাজ (মোটামুটি ১৯৮৯ থেকে ১৯৯৪) তিনটি ধারণায় সেটি সম্ভব করে। প্রথম, customization আর type feedback: প্রতিটি message-এর জায়গায় বাস্তবে কোন ধরনের object আসে তা গুনে, সেই ধরনের জন্য বিশেষ কোড। দ্বিতীয়, polymorphic inline cache (Hölzle, Chambers আর Ungar, ১৯৯১): একটি জায়গায় কয়েকটি ধরন এলে সবগুলোর ফল মনে রাখা; এটি পর্ব ০৮-এর inline cache-এর বড় ভাই। তৃতীয়, dynamic deoptimization (১৯৯২-এর PLDI প্রবন্ধ): মূলত debugger-এর জন্য, যাতে optimize-করা কোডের মাঝখানে থেমেও প্রোগ্রামার সাধারণ, অ-optimize-করা অবস্থা দেখতে পান।
তৃতীয়টি সবচেয়ে গভীর প্রভাব ফেলে, যদিও উদ্দেশ্য ছিল অন্য। একবার যদি নিশ্চিতভাবে interpreter-এর অবস্থায় ফেরা যায়, তাহলে compiler যেকোনো অনুমান করতে পারে: “এই শাখা কখনো আসে না”, “এই class-এর কোনো subclass নেই”। ভুল হলে ফেরার পথ খোলা। এই পর্বের Deopt নিয়ম ঠিক সেই নিশ্চয়তা।
দলের কয়েকজন পরে Animorphic নামের একটি ছোট প্রতিষ্ঠানে Strongtalk (টাইপ-সহ Smalltalk) বানান; সেটি কিনে নেওয়ার পর একই প্রযুক্তি Java-র HotSpot JVM-এ রূপ নেয়, যা ১৯৯৯ সালে আসে আর J2SE 1.3 (২০০০) থেকে ডিফল্ট। HotSpot-এর নামটিই এই পর্বের ধারণা: শুধু “hot spot” compile. পরে HotSpot-এর অভিজ্ঞ কয়েকজন V8 তৈরিতে যুক্ত হন (২০০৮), আর hidden class (Self-এর map-এর উত্তরসূরি) ও inline cache JavaScript-এ আসে। তারিখ আর ব্যক্তিগত ভূমিকা নিয়ে উৎসভেদে সামান্য পার্থক্য আছে।
মূল উপলব্ধি: আধুনিক JIT-এর গতি আসে অনুমান থেকে, আর অনুমান সম্ভব হয় নিশ্চিতভাবে ফেরার পথ থাকলে। Deoptimization কোনো দুর্ঘটনা সামলানোর কৌশল নয়, পুরো নকশার ভিত্তি।
প্র ০২Tracing JIT একসময় JavaScript-এর ভবিষ্যৎ মনে হয়েছিল, পরে browser-গুলো method JIT-এ ফিরে গেল; অথচ LuaJIT আর PyPy-তে tracing আজও সফল। এর কারণ কী?
Tracing-এর ধারণা ভাষার JIT-এর বাইরে থেকে আসে: HP Labs-এর Dynamo (Bala, Duesterwald আর Banerjia, PLDI ২০০০) চলমান machine code-এর গরম পথ রেকর্ড করে আবার optimize করত। Andreas Gal আর সহকর্মীদের কাজ এটিকে dynamic ভাষায় আনে, আর তার ফল TraceMonkey, যা Firefox 3.5-এ (২০০৯) JavaScript-এর প্রথম tracing JIT হিসেবে আসে। ছোট, loop-ভারী benchmark-এ এর গতি চমকপ্রদ ছিল।
সমস্যা দেখা দিল বাস্তব ওয়েব কোডে। ওয়েবের JavaScript-এ loop কম, শাখা আর ছোট function-এর ডাক বেশি, আর একটি loop-এর ভেতরে প্রায়ই অনেক দিকের শাখা থাকে। অংশ ৫-এ দেখেছেন: প্রতিটি না-দেখা দিকে side exit, তারপর নতুন side trace, আর শাখা বাড়লে trace-এর সংখ্যা দ্রুত বাড়ে (trace explosion); যে কোড trace হয় না, সে interpreter-এই থেকে যায়, তাই কর্মক্ষমতা হঠাৎ পড়ে যেত। Mozilla পরে method JIT (JägerMonkey, তারপর IonMonkey) যোগ করে, আর TraceMonkey কয়েক বছরের মধ্যে সরিয়ে নেয় (প্রায় ২০১১–২০১২; সঠিক version নিয়ে উৎসভেদে পার্থক্য আছে)। V8 শুরু থেকেই method JIT-এর পথে ছিল।
LuaJIT-এর ক্ষেত্র আলাদা। Lua ছোট, সরল ভাষা; LuaJIT 2 (Mike Pall, ২০০৯ থেকে beta) খুব যত্নে লেখা একটি trace compiler, আর এর ব্যবহারকারীরা প্রায়ই গাণিতিক, loop-ভারী কাজ চালায়, যেখানে tracing সবচেয়ে ভালো। PyPy-র meta-tracing একটি ভিন্ন সমস্যার সমাধান: interpreter লেখকের জন্য JIT প্রায় বিনামূল্যে পাওয়া; এখানে trace হয় interpreter-এর loop, আর ব্যবহারকারীর program-এর গঠন মাঝখানে একটি স্তর। CPython-এর নতুন JIT-ও trace নেয়, কিন্তু ছোট micro-op-এর, আর copy-and-patch দিয়ে সস্তায় কোড বানায়: সেখানে লক্ষ্য সর্বোচ্চ গতি নয়, কম খরচে স্থির লাভ।
মূল উপলব্ধি: কোন JIT কৌশল ভালো, তা নির্ভর করে কোডের আকৃতির ওপর: loop-ভারী সরল পথে tracing, শাখা-ভারী বড় কোডে method. একটি কৌশলকে “সেরা” বলার আগে প্রশ্ন করুন: কোন ধরনের program-এর জন্য?
প্র ০৩Haat statically typed, তাই type-এর অনুমান লাগে না। তাহলে Haat-এর মতো ভাষার JIT কী নিয়ে অনুমান করবে, আর Java-র মতো statically typed ভাষাতেও HotSpot কেন এত speculation করে?
Static type অনেক প্রশ্নের উত্তর আগেই দেয়, কিন্তু সব নয়। এই পাতার খেলনাই একটি উদাহরণ: price-এর type পুরোপুরি জানা, তবু কোন শাখা নেওয়া হবে, তা শুধু চলার সময় বোঝা যায়। Static তথ্য বলে “কী সম্ভব”, profile বলে “কী বাস্তবে ঘটে”, আর JIT-এর লাভ দ্বিতীয়টি থেকে।
Java এর সবচেয়ে বড় উদাহরণ। Java-তে প্রায় প্রতিটি method virtual: shape.area() ডাকলে কোন class-এর area চলবে, তা compile-এর সময় জানা নেই, কারণ যেকোনো সময় নতুন class load হতে পারে। HotSpot দুটি অনুমান করে। প্রথম, class hierarchy analysis: এখন পর্যন্ত load হওয়া class-গুলোর মধ্যে যদি area-র একটিই বাস্তবায়ন থাকে, তবে ডাকটি সরাসরি, এমনকি inline. পরে নতুন subclass load হলে সেই অনুমানের ওপর দাঁড়ানো কোড বাতিল, deopt. দ্বিতীয়, profile: একটি নির্দিষ্ট ডাকের জায়গায় বাস্তবে একটি বা দুটি class আসে, তাই সেগুলোর জন্য guard-সহ সরাসরি পথ (পর্ব ০৮-এর শেষের আলোচনা)। শাখার profile, null কখনো আসে কি না, array-এর সীমা কখনো পেরোয় কি না, এগুলোও HotSpot-এর অনুমানের বিষয়; এমন একটি অনুমান ভাঙলে HotSpot-এর ভাষায় একে “uncommon trap” বলা হয়।
Haat-এর ভবিষ্যৎ JIT-এর জন্য অনুমানের তালিকা তাই হতে পারে: শাখার দিক (এই পাতায় করা), একটি closure-ডাকের জায়গায় সবসময় একই function আসে কি না (higher-order function-এ খুব কাজের), আর Int-এর মান ছোট থাকে কি না, যাতে wrap-এর পরীক্ষা সস্তা হয়। শেষেরটি V8-এর Smi (small integer) ধারণার মতো; অনুমান ভাঙলে overflow-এর guard থেকে deopt.
মূল উপলব্ধি: static type speculation-এর দরকার কমায়, শেষ করে না। যে প্রশ্নের উত্তর কোডের গঠনে নেই, আছে ডেটায়, সেখানেই JIT কাজ করে।
প্র ০৪CPython-এ JIT আসতে প্রায় দুই দশক লাগল কেন, যখন Psyco, Unladen Swallow আর PyPy অনেক আগেই দেখিয়েছিল Python দ্রুত চালানো যায়?
প্রথম চেষ্টাগুলো ছিল CPython-এর বাইরে বা পাশে। Armin Rigo-র Psyco (প্রায় ২০০২–২০০৪) একটি extension module, যা চলার সময় Python function-এর বিশেষায়িত machine code বানাত; এটি শুধু ৩২-বিট x86-এ চলত আর পরে বন্ধ হয়, কারণ Rigo নিজেই PyPy-তে মন দেন। Unladen Swallow (২০০৯–২০১১) LLVM দিয়ে CPython-এর ভেতরে JIT বসানোর চেষ্টা; লক্ষ্য বড় ছিল, কিন্তু LLVM তখন JIT-এর জন্য ধীর আর ভারী, আর প্রকল্পটি মূল CPython-এ মেশেনি। PyPy সফল, কিন্তু আলাদা বাস্তবায়ন: C extension-এর সঙ্গে পুরো সামঞ্জস্য রাখা তার জন্য কঠিন, আর Python-এর ecosystem-এর বড় অংশ C extension-এর ওপর দাঁড়িয়ে।
CPython-এর নিজের বাধা তিনটি। এক, C API: হাজারো extension CPython-এর ভেতরের object-এর গঠনের ওপর নির্ভর করে, তাই JIT সেই গঠন বদলাতে পারে না। দুই, বহনযোগ্যতা আর রক্ষণাবেক্ষণ: CPython অনেক platform-এ চলে, আর মূলত স্বেচ্ছাসেবীরা চালান; প্রতিটি CPU-র জন্য হাতে লেখা code generator রাখা ভারী বোঝা। তিন, Python-এর অতি-dynamic অর্থ: যেকোনো সময় global, builtin বা class বদলানো যায় (পর্ব ১২), তাই অনুমান ভাঙার পথ সর্বত্র।
৩.১১-এর পথ তাই ধাপে ধাপে: আগে interpreter-এর ভেতরেই specialization (PEP 659), যা অনুমান আর guard-এর অভ্যাস এনেছে কিন্তু machine code ছাড়া। তারপর ৩.১৩-এ PEP 744: গরম কোডের micro-op trace, আর copy-and-patch, যার ছাঁচ build-এর সময় Clang/LLVM দিয়ে তৈরি, তাই চলার সময় LLVM লাগে না আর প্রতিটি CPU-র জন্য হাতে লেখা code generator-ও নয়। এই পাতার run দেখায়, ৩.১৪-এ এটি এখনো লাভের নিশ্চয়তা দেয় না, আর documentation-ও তাই বলে। আগামী version-এ কী হবে, তা সেই version-এর “What's New” দেখেই বলা উচিত।
মূল উপলব্ধি: একটি জনপ্রিয় ভাষার JIT শুধু compiler-এর কৌশলের প্রশ্ন নয়; সামঞ্জস্য, রক্ষণাবেক্ষণের খরচ আর ecosystem প্রায়ই প্রযুক্তির চেয়ে বড় বাধা।
প্র ০৫JIT-এর সঠিকতা কীভাবে নিশ্চিত করা হয়, যখন একটি ছোট ভুল অনুমান বা ভুলে বাদ পড়া guard চুপচাপ ভুল ফল, এমনকি নিরাপত্তার ঝুঁকি তৈরি করে?
একটি AOT compiler-এর ভুল সাধারণত সব run-এ একই রকম ঘটে। JIT-এর ভুল নির্ভর করে কোন কোড কখন গরম হলো, কোন profile জমল, এমনকি কোন thread-এ compile শেষ হলো তার ওপর: অংশ ৬-এর V8 run-এ concurrent mode-এ log-এর ক্রম প্রতিবার আলাদা ছিল। তাই একটি JIT-এর বাগ প্রায়ই শুধু নির্দিষ্ট ক্রমের call-এ, নির্দিষ্ট মানে দেখা দেয়, আর শুরুর warm-up-এর সময় একরকম, পরে আরেকরকম আচরণ করে।
প্রধান প্রতিরক্ষা তিনটি, আর তিনটিই এই পাতায় ছোট আকারে করা হয়েছে। প্রথম, differential testing: একই program JIT চালু আর বন্ধ রেখে চালিয়ে ফল মেলানো; এখানে VM বনাম JitVM বনাম reference, ৩,০০০টি এলোমেলো program-এ। Browser engine-এর দলগুলো এর বড় রূপ চালায়, এলোমেলো JavaScript বানানো fuzzer দিয়ে। দ্বিতীয়, চাপ দেওয়া: threshold নামানো আর কৃত্রিমভাবে deopt ঘটানো, যাতে বিরল পথ সাধারণ হয় (HOT = 2; V8-এর --deopt-every-n-times). তৃতীয়, mutation testing: ইচ্ছা করে বাগ বসিয়ে দেখা test সেটি ধরে কি না। অনুশীলন ২-এর বাগটি আউটপুট বদলায় না, শুধু stack-এ একটি বাড়তি মান রেখে যায়; শুধু আউটপুট মেলালে সাধারণ সেটিংয়ে ধরা প্রায় অসম্ভব।
নিরাপত্তার দিকটি কেন গুরুতর: optimize-করা কোড guard-এর ওপর ভরসা করে type-এর পরীক্ষা বাদ দেয়। ভুল করে একটি প্রয়োজনীয় guard বাদ গেলে কোড একটি মানকে ভুল type হিসেবে পড়তে পারে (type confusion), আর memory-safe ভাষার নিশ্চয়তা ভেঙে যায়। তাই engine-গুলো fuzzing, W^X মেমরি আর JIT পুরো বন্ধের বিকল্প (V8-এর --jitless) রাখে; compiler-এর সঠিকতা প্রমাণের গবেষণাও আছে (পর্ব ৪৪), তবে বাস্তব JIT-এ তা খুব সীমিত।
মূল উপলব্ধি: JIT-এর সঠিকতার মানদণ্ড সরল: interpreter-এর সঙ্গে হুবহু এক আচরণ। সেই মানদণ্ড যাচাইয়ের সবচেয়ে কার্যকর উপায় দুই বাস্তবায়নকে লক্ষবার পাশাপাশি চালানো, বিরল পথে চাপ দিয়ে।
অনুশীলন
প্রথমে নিজে করুন, তারপর উত্তর খুলে মেলান। প্রতিটি আউটপুট পাতার কোড বা reference-এর সত্যিকারের run থেকে।
-
নকশা ও বাস্তবায়ন — deopt-এর সীমা: কিছু function-এর আচরণ পর্যায়ক্রমে বদলায়, তাই সে বারবার compile আর deopt হয়, প্রতিবার compile-এর খরচ দিয়ে।
JitVM-কে বাড়িয়েCappedJitVMলিখুন: একটি function তিনবার deopt হলে সে আর কখনো compile হবে না, আর log-এ লেখা হবেfee: 3 deopts, give up. শর্ত: আউটপুট একটুও বদলাবে না। নিচের program দিয়ে পরীক্ষা করুন:fn fee(w: Int) -> Int { if w > 30 { return 300; } if w > 20 { return 200; } if w > 10 { return 100; } return 50; } var i = 0; var s = 0; while i < 400 { s = s + fee(i / 100 * 10 + 5); i = i + 1; } print(s);Deopt চেনার সহজ উপায়: call-এর আগে compile-করা কোড ছিল, পরে নেই।
class CappedJitVM(JitVM): MAX_DEOPTS = 3 # after the 3rd deopt: stay in the VM for good def __init__(self, main, out=print): super().__init__(main, out); self.deopts = Counter() def op_CALL(self, f, n, name): code = self.stack[-n - 1].code; was_fast = self.fast.get(code) is not None super().op_CALL(f, n, name) if was_fast and code not in self.fast: # this call deoptimized self.deopts[code] += 1 if self.deopts[code] >= self.MAX_DEOPTS: self.hot_at[code] = None # never equal to a call count again self.log.append(f"{code.name}: {self.deopts[code]} deopts, give up")ল্যাবের সত্যিকারের run (reference-এর
vm-ও ছাপে65000):JitVM ['65000'] fee: call 50, compiled fee: call 101, deopt at ip 15, slots [15] fee: call 151, compiled fee: call 201, deopt at ip 9, slots [25] fee: call 251, compiled fee: call 301, deopt at ip 3, slots [35] fee: call 351, compiled CappedJitVM ['65000'] … প্রথম ছয় লাইন একই … fee: 3 deopts, give upi / 100 * 10 + 5প্রতি ১০০টি call-এ ওজন বদলায়: 5, 15, 25, 35. প্রতিবার নতুন একটিifপ্রথমবার সত্য হয়, তাই আগের profile-এ না-দেখা দিক: deopt ip 15, 9, তারপর 3 (তিনটিJUMP_IF_FALSE-এর অবস্থান)। সীমা না থাকলে চারবার compile হয়; সীমা থাকলে তিনবার, আর শেষ ১০০টি call VM-এ। একইCappedJitVMলেখকের যন্ত্রে ৩,০০০টি এলোমেলো program-এHOT২ আর ৫০ দুটিতেই reference-এর সঙ্গে ৩,০০০ / ৩,০০০ মিলেছে। বাস্তব engine-ও এমন সীমা রাখে, যাতে একটি function “deopt loop”-এ আটকে না যায়। -
ভুল খুঁজুন — এক ঘর পরে ফেরা: একজন guard-এর লাইনটি “সরল” করলেন, যাতে VM-কে আবার শাখার নির্দেশ চালাতে না হয়:
raise Deopt({i}, …)-এর বদলেraise Deopt({i + 1}, …), বাকি সব একই।hot.haat-এর আউটপুট তবুও143640,1080,215688. ভুলটি কী, আউটপুট কেন ঠিক দেখায়, আর কোন test এটি ধরবে?দুটি ভুল একসঙ্গে। প্রথম, stack: guard
t-কে stack-এ রেখে ফেরে, ip 7-এরJUMP_IF_FALSEযাকে নামাত; ip 8-এ ফিরলে কেউ নামায় না, তাই একটি বাড়তিTruestack-এ থেকে যায়। দ্বিতীয়, সঠিকতা:if tguard-এ VM-এর পড়ে যাওয়ার দিক ip 8, তাই এখানে দিকটি কাকতালীয়ভাবে ঠিক; কিন্তু উল্টো guard (if not t, ফেরার কথা লাফের লক্ষ্যে) হলে ipi + 1ভুল শাখা, অর্থাৎ ভুল ফল। তৃতীয় একটি ছোট ক্ষতি: শাখাটি VM-এ আর চলে না, তাই profile নতুন দিকটি শেখে না।আউটপুট কেন ঠিক:
RETURNশুধু ওপরের মানটি ফল হিসেবে রাখে, নিচের বাড়তি মান কেউ পড়ে না। ল্যাবে এই বাগ বসিয়েhot.haat-এর আউটপুট ঠিক, কিন্তু শেষে stack[True], সঠিক JIT-এ[]. ৩,০০০টি এলোমেলো program-এ সত্যিকারের সংখ্যা:HOT = 50-এ মাত্র ২৩টিতে আউটপুট আলাদা,HOT = 2-এ ৭২১টিতে; ১৪টি হাতে লেখা উদাহরণের মধ্যেHOT = 2-এ ৩টিতে আরHOT = 50-এ ১টিতে। শিক্ষা: run শেষে “stack খালি” assertion রাখুন, যা এই বাগ প্রথম deopt-এই ধরে, আর কম threshold দিয়ে চাপ দিন। একইভাবে আরও দুটি বাগ:MUL-এwrapভুলে যাওয়া ধরা পড়েছে ২৬টি (HOT = 2) আর ১৪টি (HOT = 50) program-এ, কারণ বেশিরভাগে overflow ঘটেই না; Deopt-এ শুধু parameter ফেরানো ধরা পড়েছে ৪২৪টি আর ৮৫টিতে। আর compile-করা call-এ ১,০০০ স্তরের সীমা-পরীক্ষা বাদ দিলে ৩,০০০-এর একটিতেও ধরা পড়েনি (generator কখনো গভীর recursion বানায় না); ধরেছে শুধু হাতে লেখাdeep.haat, যেখানে ১,০০১তম স্তরে একটি গরম leaf function ডাকা হয়। -
Trace করুন:
JitVM-এরHOT= 3. পরিচিতprice(let p = qty * unit; if p >= 1000 { return p - p / 10; } return p;) এই ক্রমে আটবার ছাপা হয়:price(1, 120),(2, 120),(3, 120),(9, 120),(4, 120),(5, 120),(6, 120),(10, 120). আউটপুট কী, log-এ কোন তিনটি ঘটনা কোন call-এ, VM-এprice-এর মোট কতগুলো নির্দেশ চলবে, আর শেষ compile-এ guard থাকবে কি না?ল্যাবের সত্যিকারের run (reference-এর
vm-এর আউটপুটও একই আট লাইন):['120', '240', '360', '972', '480', '600', '720', '1080'] price: call 3, compiled price: call 4, deopt at ip 7, slots [9, 120, 1080] price: call 7, compiled price instructions interpreted: 47Call ১ আর ২ VM-এ (১০ + ১০টি নির্দেশ), দুবারই শাখা লাফ দেয়। Call ৩-এ compile, profile ২ / ০, তাই guard-সহ। Call ৪-এ
9 * 120 = 1080, guard ভাঙে; VM ip 7 থেকে ৭টি নির্দেশ চালায়, ফল1080 - 108 = 972; পরের compile call ৪ + ৩ = ৭-এ। Call ৫ আর ৬ VM-এ (আরও ২০টি)। মোট ২০ + ৭ + ২০ = ৪৭. Call ৭-এ compile, এবার profile ৪ / ১ (দুই দিকই), তাই guard নেই, আর call ৮ (10 * 120 = 1200, ফল1080) compile-করা কোডের ছাড়ের block-এ চলে, কোনো deopt ছাড়া। -
প্রমাণ — spill কেন দরকার: ধরুন compiler
STORE_LOCAL-এর আগেspillকরে না। একটি Haat bytecode-এর টুকরো দিন (যেকোনো Haat program থেকে আসুক বা না আসুক) যেখানে তখন generated কোড VM থেকে আলাদা ফল দেয়; তারপর দেখান যে Haat-এর compiler (পর্ব ৫৮)-এর তৈরি কোডে এমন টুকরো কখনো আসে না, অর্থাৎ বাস্তবে spill শুধু নিরাপত্তার জন্য।পাল্টা উদাহরণ. একটি function, arity ১, consts[0] = 1:
LOAD_LOCAL 0; CONST 0; STORE_LOCAL 0; LOAD_LOCAL 0; ADD; RETURN, argument 5. VM: stack [5], তারপর slot 0 = 1, তারপর [5, 1],ADDদেয় 6. Spill ছাড়া compiler: st = [v0], লেখেv0 = 1, তারপর st = [v0,v0], ফলwrap(v0 + v0), অর্থাৎ 2. ল্যাবে হাতে বানানো এইCode-এ সত্যিকারের run: VM দেয়6, spill-সহjit_source-এর কোড (s0 = v0,v0 = 1,return wrap(s0 + v0)) দেয়6, spill বাদ দেওয়া সংস্করণ দেয়2. কারণ symbolic stack-এ রাখাv0একটি নাম, মান নয়; নামের মান পরে বদলেছে। Spill থাকলেs0 = v0(মান 5 ধরে রাখা) তারপরv0 = 1, ফলwrap(s0 + v0)= 6, VM-এর সঙ্গে এক।Haat-এর compiler-এ কেন আসে না (প্রমাণের রূপরেখা).
- পর্ব ৫৮-এর statement-এর চুক্তি: প্রতিটি statement stack যেমন পেয়েছিল তেমনই রাখে, আর
STORE_LOCALআসে শুধু statement থেকে (let, assignment; সিদ্ধান্ত ৯ অনুযায়ী assignment expression নয়)। - একটি function-এর শরীরের প্রতিটি statement শুরু হয় খালি stack-এ (শরীর খালি stack-এ শুরু, আর চুক্তি অনুযায়ী প্রতিটি statement-এর পরে আবার খালি)।
let x = e;বাx = e;-এর কোড: C(e) তারপরSTORE. Expression-এর চুক্তি অনুযায়ী C(e) শেষে stack-এ ঠিক একটি মান, নিচে কিছু নেই। তাইSTORE_LOCAL-এর মুহূর্তে st-এ শুধু x-এর মান, নিচে কোনো লেখা নেই যা পুরোনো slot-এর ওপর নির্ভর করতে পারে।- অতএব Haat-এর compiler-এর কোডে spill-এর আগে st সবসময় খালি, আর spill কিছুই লেখে না; পাল্টা উদাহরণের আকার (একটি expression-এর মাঝখানে store) শুধু হাতে লেখা bytecode-এ সম্ভব। ∎
তবু spill রাখার কারণ: JIT-এর input যাচাই না করা bytecode-ও হতে পারে (JVM-এর মতো যেখানে bytecode অন্য compiler থেকে আসে), আর তখন এই অনুমান ভাঙবে। JVM এ জন্যই class load-এর সময় bytecode verifier চালায়।
- পর্ব ৫৮-এর statement-এর চুক্তি: প্রতিটি statement stack যেমন পেয়েছিল তেমনই রাখে, আর
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি profile-নির্ভর JIT একটি function-কে প্রথম call থেকে প্রথম deopt পর্যন্ত নিয়ে যায়। ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Interpreter function চালায় আর call ও শাখার দিক গোনে
- Call-এর সংখ্যা সীমায় পৌঁছায়
- Compiler profile পড়ে, না-দেখা শাখার জায়গায় guard বসিয়ে কোড বানায়
- পরের call-গুলো compile-করা কোডে চলে, profile আর বাড়ে না
- একটি call-এ guard ভাঙে আর Deopt slot ও stack নিয়ে আসে
- Interpreter সেই অবস্থা থেকে শাখার নির্দেশ চালায় আর নতুন দিকটি profile-এ লেখে
একটি JIT price-কে compile করেছে এই অনুমানে যে if p >= 1000 কখনো সত্য হয় না। এখন একটি call-এ p = 1200. সঠিক JIT কী করবে?
- compile-করা কোডের অন্য শাখাটি চালিয়ে যাবে, কারণ সেটিই আছে
- একটি runtime error দেবে
- Guard ভাঙবে, interpreter-এর সমান অবস্থা গড়ে সেখান থেকে চলবে (deoptimization)
- পুরো program শুরু থেকে interpreter-এ আবার চালাবে
একটি program-এর প্রায় সব সময় যায় top level-এর একটি বড় while loop-এ, যা একবারই চলে। শুধু function-call গুনে compile করা একটি JIT-এ কোন কৌশল না থাকলে এই loop কখনো দ্রুত হবে না?
- On-stack replacement (OSR)
- Inlining
- Inline cache
- Deoptimization
Tracing JIT আর method JIT-এর পার্থক্য কোনটি সবচেয়ে সঠিকভাবে বলে?
- Tracing JIT machine code বানায় না, শুধু bytecode বদলায়
- Method JIT guard রাখে, tracing JIT রাখে না
- Tracing JIT শুধু একটি function-এর ভেতরেই কাজ করতে পারে
- Method JIT পুরো function compile করে; tracing JIT একটি গরম loop-এর আসলে চলা একটি পথ, শাখায় guard রেখে
python.org-এর Windows build-এর CPython 3.14-এর JIT সম্পর্কে কোন কথাটি সঠিক?
- এটি ডিফল্টে চালু আর সব কোড দ্রুত করে
- এটি পরীক্ষামূলক, ডিফল্টে বন্ধ,
PYTHON_JIT=1দিয়ে চালু হয়, আর কিছু কাজে ধীরও হতে পারে python -Oদিয়ে চালু হয়- CPython-এ কোনো JIT নেই, কারণ Python একটি interpreted ভাষা
Haat statically typed: type checker প্রমাণ করে প্রতিটি --এর দুই পাশ Int. তাহলে Haat-এর একটি JIT-এর জন্য নিচের কোন speculation এখনো লাভজনক?
- “
--এর দুই পাশ Int” — type guard বসানো - “
CONST 1000-এর মান ১,০০০” — guard বসানো - “এই
if-এর শর্ত কখনো সত্য হয় না” — না-দেখা শাখা বাদ দিয়ে guard - “top-level function
price-এর নামে সবসময় একই function” — guard বসানো
Node 24-এ node --trace-deopt একটি function-এর জন্য ছাপল reason: Insufficient type feedback for generic named access, আর bytecode offset-টি এমন একটি শাখার ভেতরে, যা আগে কখনো চলেনি। এর সবচেয়ে সম্ভাব্য ব্যাখ্যা কোনটি?
- Optimize করার সময় শাখাটি কখনো চলেনি, তাই সেখানে feedback ছিল না আর compiler deopt বসিয়েছিল; প্রথমবার শাখায় ঢুকতেই সেটি ঘটল
- Program-এ একটি runtime error হয়েছে
- Engine-এর মেমরি শেষ হয়ে গেছে
- Ignition-এর bytecode ভুল ছিল
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- আগে গোনা, পরে compile: interpreter call, back edge, শাখার দিক আর type গোনে; শুধু গরম কোড ওপরের স্তরে ওঠে (tiered compilation).
- Bytecode থেকে কোড: basic block, symbolic stack আর spill; ফলের অর্থ VM-এর সঙ্গে হুবহু এক (wrap, C-ধরনের ভাগ, error-এর অবস্থান)।
- অনুমান + guard + deopt: না-দেখা দিক compile হয় না; guard ভাঙলে slot, stack আর ip দিয়ে VM-এর অবস্থা গড়ে শাখার নির্দেশ থেকে চলা। OSR তার আয়না।
- Method বনাম trace: পুরো function বনাম গরম loop-এর একটি পথ; LuaJIT, PyPy আর CPython 3.13+ trace নেয়, V8 আর HotSpot method.
- মাপুন, ধরে নেবেন না: V8-এ সব স্তর প্রায় ২৫ গুণ দ্রুত, CPython 3.14-এর পরীক্ষামূলক JIT কাজভেদে সামান্য দ্রুত বা ধীর, আর খরুচে profiling খেলনা JIT-এর লাভ খেয়ে ফেলে; সঠিকতা যাচাই হয় JIT চালু-বন্ধ রেখে differential test-এ, কম threshold-এ চাপ দিয়ে।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ৬২ · Intermediate representation — three-address code আর control flow graphপরবর্তী পর্বoptimizer-এর কাজের ভাষা।
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্ব১৪টি মডিউলের পুরো মানচিত্র আর Haat প্রজেক্টের পথ।
- পর্ব ৫৮ · Bytecode নকশা — instruction set আর compiler থেকে bytecodeআগের ধাপএই পাতার JIT যে bytecode পড়ে।
- পর্ব ০৪ · অনুবাদক — compiler, interpreter, transpiler আর JITভিত্তিAOT বনাম JIT-এর আপস আর CPython, Java, JavaScript-এর মিশ্র পথ।
- JavaScript · পর্ব ০৫ · JavaScript কীভাবে চলেপাশের ট্র্যাকV8-এর engine, JIT আর call stack.
- Java · পর্ব ০৫ · Java কীভাবে চলেপাশের ট্র্যাকjavac, HotSpot আর tiered compilation.