এই পর্বে যা শিখবেন
- Subroutine আর coroutine-এর পার্থক্য, আর generator কোথায় থামে, কী মনে রাখে, তা ধাপে ধাপে চালিয়ে দেখা
- Semi বনাম symmetric, stackless বনাম stackful coroutine: কোন ভাষা কোন পথ নিয়েছে আর কেন
- একটি generator-কে হাতে state machine-এ নামানো, আর CPython-এর আসল bytecode-এ সেই কৌশল চেনা
- Haat-এর বর্ধিত রূপে
yieldযোগ করার নকশা, আর VM-এ frame বাঁচিয়ে রাখার উপায় - নিজে একটি ছোট event loop লেখা, async/await-এর ক্রম আগে থেকে বলা, আর continuation-এর ধারণা
১ · Subroutine আর coroutine — মাঝপথে থামা function
পাড়ার দর্জির দোকানে একজন কারিগর একসাথে তিনটি জামার অর্ডার নিয়েছেন। প্রথম জামা কলার পর্যন্ত সেলাই হলো, কিন্তু বোতাম শেষ। তিনি জামাটি ফেলে দেন না, আবার গোড়া থেকেও শুরু করেন না। একটি চিরকুট লাগিয়ে রাখেন: “কলার পর্যন্ত হয়েছে, এরপর বোতাম।” তারপর দ্বিতীয় জামা ধরেন। বোতাম এলে চিরকুট দেখে ঠিক সেই জায়গা থেকে আবার শুরু।
সাধারণ function এমন পারে না। তাকে বলে subroutine: ডাকলে শুরু থেকে শেষ পর্যন্ত চলে, তারপর ফেরে, আর ফেরার সময় তার activation record (stack-এর frame, যেখানে local variable থাকে) মুছে যায়। পরের ডাক আবার শূন্য থেকে শুরু। Coroutine হলো সেই কারিগর: মাঝপথে থামতে (suspend) পারে, নিয়ন্ত্রণ অন্য কাউকে দিতে পারে, আর পরে চিরকুট দেখে আবার চলতে (resume) পারে। চিরকুটটি দুটি জিনিস: কোন লাইনে থেমেছিল, আর local variable-গুলোর মান।
নামটি পুরোনো। প্রচলিত বিবরণে Melvin Conway ১৯৫৮ সালের দিকে শব্দটি ব্যবহার করেন, আর ১৯৬৩ সালে একটি COBOL compiler-এর নকশার প্রবন্ধে প্রকাশ করেন: lexer আর parser দুটি coroutine, যারা একে অপরকে পালা করে নিয়ন্ত্রণ দেয়। Simula 67-এ ভাষার ভেতরেই coroutine ছিল, আর Donald Knuth ১৯৬৮ সালে The Art of Computer Programming-এর প্রথম খণ্ডে একে subroutine-এর সমান মর্যাদা দেন। আজ একই ধারণা তিন রূপে ছড়িয়ে আছে: generator (Python, JavaScript, C#), async/await (প্রায় সব মূলধারার ভাষা), আর হালকা thread (Go, Lua, Java 21-এর virtual thread).
ছবি ৩১.১ — Subroutine একবার ঢোকে, একবার বেরোয়; coroutine বারবার থামে আর চলে
ডানের মানগুলো অংশ ২-এর সত্যিকারের run থেকে (slots generator)
এই পর্ব আগের কয়েকটি পর্বের সুতো এক জায়গায় বাঁধে। পর্ব ২৭-এ দেখেছেন for-each আসলে iterator protocol-এর ডাক; পর্ব ১৯-এ generator দিয়ে lazy stream; পর্ব ১০-এ generator দিয়ে backtracking; আর পর্ব ১১-এ JavaScript-এর event loop-এ microtask আর timer-এর ক্রম। সেগুলো আবার বলা হবে না। এখানে প্রশ্ন একটিই: একটি function থামে কীভাবে, অর্থাৎ ভাষা আর compiler “চিরকুট” কোথায় রাখে, আর সেই কৌশলের ওপর async/await কীভাবে দাঁড়ায়।
২ · Generator — yield, next আর send
সবচেয়ে পরিচিত coroutine হলো generator. Python-এ (২০০১ সালে Python 2.2, PEP 255) body-তে yield থাকলেই একটি function generator function হয়ে যায়; JavaScript-এ (ES2015) লিখতে হয় function*. নিয়ম তিনটি:
- ডাকলে body চলে না। শুধু একটি generator object তৈরি হয়, যার ভেতরে frame প্রস্তুত, কিন্তু একটি লাইনও চলেনি।
next()পরেরyieldপর্যন্ত চালায়।yield t-এ মান t বাইরে যায়, আর frame সেখানেই থেমে থাকে।send(v)থামার জায়গায় একটি মান ঢোকায়। Python 2.5-এর PEP 342 থেকেyieldএকটি expression: থামা অবস্থা থেকে ফেরার সময় তার মান হয় v.next(g)মানেg.send(None). body শেষ হলেStopIteration, আরreturn-এর মান থাকে তারvalue-তে।
বাজারঘরের ডেলিভারি-স্লটের একটি generator চালিয়ে দেখুন। সময় দিনের মিনিটে (600 মানে সকাল ১০টা); প্রতিবার ৩০ মিনিট পরের স্লট, কিন্তু ডাকা-পক্ষ চাইলে send() দিয়ে ফাঁক বদলাতে পারে। inspect.getgeneratorstate generator-এর অবস্থা বলে, আর gi_frame.f_locals দেখায় থেমে থাকা frame-এ কী বাঁচিয়ে রাখা আছে।
# বাজারঘরের ডেলিভারি-স্লট: একটি generator কোথায় থামে, কী মনে রাখে
from inspect import getgeneratorstate as state
def slots(start, n): # start = দিনের মিনিট (600 = সকাল 10:00)
print(" [gen] body starts")
t = start
for i in range(n):
got = yield t # এখানে থামে; send()-এর মান got-এ আসে
print(f" [gen] resumed, got={got}")
t += 30 if got is None else got
print(" [gen] body ends")
return "no more slots"
g = slots(600, 3) # body এখনো চলেনি
print("created:", state(g))
print("next ->", next(g), state(g))
print(" saved locals:", g.gi_frame.f_locals)
print("send(45) ->", g.send(45))
print("next ->", next(g))
try:
next(g)
except StopIteration as e:
print("StopIteration, value =", repr(e.value), state(g))
print("frame after end:", g.gi_frame)আসল আউটপুট (ব্রাউজারের Python; লেখকের CPython 3.14.4-এও হুবহু এক):
created: GEN_CREATED
[gen] body starts
next -> 600 GEN_SUSPENDED
saved locals: {'start': 600, 'n': 3, 't': 600, 'i': 0}
[gen] resumed, got=45
send(45) -> 645
[gen] resumed, got=None
next -> 675
[gen] resumed, got=None
[gen] body ends
StopIteration, value = 'no more slots' GEN_CLOSED
frame after end: None
প্রথম লাইনেই নিয়ম ১: slots(600, 3) ডাকার পরেও “body starts” ছাপা হয়নি। next-এর পরে থেমে থাকা frame-এ t আর i আছে, কিন্তু got নেই, কারণ yield-এর ফল এখনো কোথাও বসেনি। send(45)-এর 45 ঢুকল got-এ, তাই পরের স্লট 645; সাধারণ next-এ got হলো None, তাই ৩০ মিনিট যোগ। শেষে return-এর মান StopIteration-এর ভেতরে এল, আর frame মুছে গেল (None). অর্থাৎ frame-এর আয়ু এখানে ডাকের সঙ্গে বাঁধা নয়, generator object-এর সঙ্গে বাঁধা।
1def slots(start, n):2 t = start3 for i in range(n):4 got = yield t5 t += 30 if got is None else got6 return "no more slots"7g = slots(600, 3)8next(g)9g.send(45)10next(g)11next(g)
| অবস্থা | |
| থেমেছে | |
| t, i | |
| got |
- তৈরি, চলেনি।
slots(600, 3)একটি generator object দেয়। frame-এ শুধু parameter (start = 600, n = 3); অবস্থা GEN_CREATED. - প্রথম next. body শুরু: t = 600, loop-এর প্রথম round-এ i = 0, তারপর লাইন ৪-এর
yield t: 600 বাইরে যায়, frame সেখানেই থামে। - send(45). থামা
yield-এর মান হয় 45, তাই got = 45; t = 600 + 45 = 645; পরের round-এ i = 1, আবার লাইন ৪-এ থেমে 645 দেয়। - আবার next. got = None, তাই ৩০ যোগ: t = 675, i = 2; আবার থামা।
- শেষ next. got = None, t = 705; range(3) ফুরিয়েছে, তাই loop শেষ,
returnচলে। ডাকা-পক্ষ পায় StopIteration (value = 'no more slots'), আর frame মুছে যায়।
JavaScript-এর generator একই নিয়মে চলে, ছোট কয়েকটি পার্থক্যসহ। সেখানে send নেই: g.next(v) নিজেই মান ঢোকায়, আর প্রথম next-এর argument হারিয়ে যায়, কারণ তখনো কোনো থেমে থাকা yield নেই যে মানটি নেবে। ফল আসে {value, done} object হিসেবে, আর return-এর মান আসে done: true-এর সঙ্গে (for…of সেটি উপেক্ষা করে)। দুই ভাষাতেই বাইরে থেকে generator থামানোর পথ আছে: Python-এ throw() আর close(), JavaScript-এ throw() আর return(). দুটিই থেমে থাকা yield-এর জায়গায় একটি exception বা “ফেরো” সংকেত ঢোকায়, যাতে body-র finally চলতে পারে (অনুশীলন ৩)।
Generator-এর আসল শক্তি এখানে: ডাকা-পক্ষ আর generator দুজনেই নিজের নিজের loop লেখে, কেউ কারও callback নয়। এই পর্বের Python অংশের বিস্তারিত পাবেন Python কোর্সের পর্ব ৩৬-এ, JavaScript-এর JavaScript কোর্সের পর্ব ২৭-এ.
৩ · কোথায় থামা যায় — semi বনাম symmetric, stackless বনাম stackful
“Coroutine” শব্দের নিচে আসলে কয়েক রকম ব্যবস্থা লুকিয়ে আছে। Ana Lúcia de Moura আর Roberto Ierusalimschy (Lua-র নকশাকারদের একজন) “Revisiting Coroutines” প্রবন্ধে (২০০৪ সালের রিপোর্ট, ২০০৯ সালে জার্নালে) তিনটি প্রশ্ন দিয়ে এদের ভাগ করেন। প্রথম দুটি এখানে সবচেয়ে কাজের:
- থামলে নিয়ন্ত্রণ কোথায় যায়? Semi-coroutine (asymmetric) থামলে সবসময় যে তাকে চালিয়েছে তার কাছে ফেরে, ঠিক function call-এর মতো একটি জোড়া: resume আর yield. Symmetric coroutine-এ একটি coroutine সরাসরি অন্য যেকোনো coroutine-এ নিয়ন্ত্রণ পাঠায় (transfer), কারও কাছে ফেরার দায় নেই। প্রবন্ধটির দেখানো একটি ফল: stackful হলে দুটির ক্ষমতা সমান, একটি দিয়ে অন্যটি বানানো যায়; তবে asymmetric রূপটি বোঝা আর ব্যবহার করা সহজ।
- কতটা গভীর থেকে থামা যায়? Stackless coroutine শুধু নিজের body-র ভেতরে থামতে পারে; তার ভেতর থেকে ডাকা কোনো সাধারণ function-এর ভেতরে থামতে পারে না, কারণ বাঁচিয়ে রাখা হয় শুধু একটি frame. Stackful coroutine নিজের একটি পুরো stack পায়, তাই দশ স্তর নিচের function থেকেও থামতে পারে।
| ভাষা ও ব্যবস্থা | ধরন | থামার জায়গা |
|---|---|---|
Python generator, async def | semi, stackless | শুধু নিজের body-তে; গভীরে নিতে yield from বা await প্রতিটি স্তরে |
JavaScript function*, async function | semi, stackless | শুধু নিজের body-তে; yield* বা await প্রতিটি স্তরে |
| C++20 coroutine | stackless | co_await, co_yield শুধু coroutine-এর body-তে; frame সাধারণত heap-এ |
Lua 5.0 (২০০৩) থেকে coroutine | semi, stackful | ভেতরের যেকোনো Lua function থেকে coroutine.yield |
| Java 21 virtual thread, Go goroutine | stackful, runtime-নিয়ন্ত্রিত | যেকোনো blocking ডাকে runtime নিজে থামায়; প্রোগ্রামার yield লেখেন না |
Stackless হওয়ার ফল Python-এ নিজে দেখা যায়। নিচে helper-এর ভেতরে yield আছে, তাই helper নিজেই একটি generator হয়ে যায়; তাকে সাধারণভাবে ডাকলে কিছুই হয় না। বাইরের generator-এর মাধ্যমে মান পার করতে হলে লিখতে হয় yield from (Python 3.3, PEP 380). সত্যিকারের run (CPython 3.14.4):
def helper(t):
yield t # helper নিজেই generator হয়ে যায়
def slots2():
helper(600) # শুধু একটি object তৈরি, কিছু চলে না
yield from helper(630) # ভেতরের সব মান বাইরে পার করে
print(list(slots2()))
[630]
600 হারিয়ে গেল, এসেছে শুধু 630. প্রতিটি স্তরকে নিজে generator হতে হয়, আর প্রতিটি ডাকে yield from লিখতে হয়। async/await-এর বেলায় একই নিয়মের নাম “function-এর রঙ”, যা অংশ ৭-এ আসবে। বিনিময়ে লাভ বড়: থেমে থাকা অবস্থার জন্য পুরো stack নয়, কেবল একটি ছোট frame লাগে, আর compiler ঠিক জানে কোথায় কোথায় থামা সম্ভব।
৪ · Compiler-এর কৌশল — generator থেকে state machine
যে প্রসেসর বা VM-এ “থামো আর পরে চলো” বলে কোনো নির্দেশ নেই, সেখানে generator চলে কীভাবে? উত্তর: compiler একে একটি সাধারণ object আর একটি সাধারণ method-এ নামায়, যাকে বলে state machine. পর্ব ২৭-এর lowering-এর মতোই, শুধু এবার নামানো হচ্ছে “থামা”-কে। নিয়মগুলো:
- প্রতিটি
yield-এর জায়গাকে একটি নম্বর দেওয়া হয় (অবস্থা 1, 2, …); শুরু হলো অবস্থা 0, শেষ হলো আলাদা একটি অবস্থা। - যে local variable কোনো
yieldপেরিয়েও বাঁচে, সেটি object-এর field হয়ে যায়, কারণ method থেকে return করলে তার নিজের frame মুছে যাবে। for-loop-এর লুকানো iterator-ও এমন একটি variable. yield vহয়ে যায়: অবস্থা-নম্বর লেখা, তারপরreturn v.- method-এর শুরুতে অবস্থা-নম্বর দেখে সঠিক জায়গায় লাফ: একটি switch.
নিচের block-এ একটি বিল-হিসাবের generator আর তার হাতে নামানো রূপ পাশাপাশি। দুটিকে একই ক্রমে next আর send দেওয়া হয়, আর ফল মেলানো হয়: এক ধরনের differential testing.
# একই generator, দুই রূপে: Python-এর আসল yield, আর হাতে নামানো state machine
def bill(items): # প্রতিটি দামের পরে চলতি মোট
total = 0
for price in items:
if price <= 0: continue
total += price
extra = yield total # send() দিয়ে ছাড় আসতে পারে
if extra: total -= extra
return total
class BillSM: # compiler যা বানায়, তার হাতে লেখা রূপ
def __init__(self, items):
self.state, self.items = 0, items # local variable এখন field
def __next__(self): return self.send(None)
def send(self, v):
if self.state == 0: # প্রথমবার: body-র শুরু
self.total, self.it = 0, iter(self.items)
elif self.state == 1: # yield-এর ঠিক পর থেকে
if v: self.total -= v
else: raise StopIteration # শেষ হয়ে গেছে
for price in self.it: # loop চলে আগের জায়গা থেকে
if price <= 0: continue
self.total += price
self.state = 1
return self.total # = yield total
self.state = 2
raise StopIteration(self.total) # = return total
def drive(g): # একই ডাকের ক্রম দুই রূপে
out = [next(g), g.send(50), next(g)]
try: next(g)
except StopIteration as e: out.append(("end", e.value))
return out
a, b = drive(bill([400, 0, 250, 300])), drive(BillSM([400, 0, 250, 300]))
print("generator:", a); print("lowered: ", b); print("same:", a == b)আসল আউটপুট (ব্রাউজারের Python):
generator: [400, 600, 900, ('end', 900)]
lowered: [400, 600, 900, ('end', 900)]
same: True
দুই রূপ হুবহু এক। লক্ষ করুন self.it: loop-এর লুকানো iterator-কেও field বানাতে হয়েছে। এটি ভুলে গিয়ে প্রতিবার for price in self.items লিখলে loop প্রতিটি ডাকে তালিকার গোড়া থেকে শুরু হতো (অনুশীলন ২-এ এই ভুলটিই ধরতে হবে)। এখানে একটিই yield, তাই অবস্থা মাত্র তিনটি: 0 (শুরু), 1 (yield-এর পরে), 2 (শেষ)। আসল compiler-এ একটি switch প্রতিটি yield-এর পরের জায়গায় লাফ দেয়; Python-এ লাফ নেই বলে এখানে for-loop-টি নিজেই সেই জায়গা।
1g = BillSM([400, 0, 250, 300])2next(g) # = send(None)3g.send(50)4next(g)5next(g)6next(g)
| state | |
| total | |
| it-এ বাকি |
- তৈরি। শুধু
state = 0আর তালিকা রাখা হলো; body-র কোনো কাজ হয়নি, ঠিক generator-এর নিয়ম ১-এর মতো। - state 0. শুরুর শাখা: total = 0, iterator তৈরি। 400 যোগ,
state = 1লিখে 400 return; iterator-এ বাকি 0, 250, 300. - state 1, v = 50. yield-এর পরের কাজ: total = 400 − 50 = 350. loop আগের জায়গা থেকে: 0 বাদ (continue), 250 যোগে 600, return 600. বাকি শুধু 300.
- state 1, v = None. ছাড় নেই। 300 যোগে 900, return 900. iterator এখন খালি।
- loop শেষ। iterator-এ কিছু নেই, তাই
state = 2আরStopIteration(900): generator-এরreturn total-এর সমান। - state 2. শেষ হওয়া generator-কে আবার ডাকলে মানহীন StopIteration; আসল Python generator-ও ঠিক তাই করে (দুই রূপেই চালিয়ে মেলানো)।
আসল compiler কী করে
C# 2.0 (২০০৫)-এর yield return আর C# 5.0 (২০১২)-এর async: দুটিই compiler একটি লুকানো class-এ নামায়, যার একটি state field আর একটি MoveNext method আছে, ঠিক উপরের ধাঁচে। পুরোনো browser-এর জন্য Regenerator নামের open-source tool JavaScript-এর generator-কে ES5-এর switch-ভিত্তিক state machine-এ বদলাত। Rust-এর async fn একটি enum হয়ে যায়, যার প্রতিটি variant একটি await-বিন্দুর বাঁচানো variable ধরে; Kotlin-এর suspend function একটি continuation object আর state label পায়।
CPython অন্য পথ নেয়: সে frame-কেই বাঁচিয়ে রাখে, আলাদা class বানায় না। CPython 3.14.4-এর নিজের dis (সত্যিকারের run, একটু ছোট করা generator):
def slots(start, n):
t = start
for i in range(n):
yield t
t += 30
2 RETURN_GENERATOR
POP_TOP
L1: RESUME 0
3 LOAD_FAST 0 (start)
STORE_FAST 2 (t)
4 LOAD_GLOBAL 1 (range + NULL)
LOAD_FAST_BORROW 1 (n)
CALL 1
GET_ITER
L2: FOR_ITER 16 (to L3)
STORE_FAST 3 (i)
5 LOAD_FAST_BORROW 2 (t)
YIELD_VALUE 0
RESUME 5
POP_TOP
6 LOAD_FAST_BORROW 2 (t)
LOAD_SMALL_INT 30
BINARY_OP 13 (+=)
STORE_FAST 2 (t)
JUMP_BACKWARD 18 (to L2)
4 L3: END_FOR
...
প্রথম নির্দেশ RETURN_GENERATOR: function ডাকামাত্র frame-টি একটি generator object-এ ঢুকিয়ে সেটিই ফেরত দেয়; এটিই নিয়ম ১-এর বাস্তবায়ন। YIELD_VALUE মানটি বাইরে দিয়ে থামে, আর frame মনে রাখে কোন নির্দেশে থেমেছিল; পরের send-এ চলা শুরু হয় ঠিক পরের RESUME থেকে। লক্ষ করুন: yield-এর মুহূর্তে range-এর iterator frame-এর নিজস্ব value stack-এ পড়ে আছে (GET_ITER সেখানে রেখেছিল)। CPython-এর প্রতিটি frame-এর নিজস্ব value stack থাকে, তাই frame বাঁচালেই সব বাঁচে। হাতে নামানো রূপে সেই iterator-কেই self.it বানাতে হয়েছিল।
৫ · Haat-এর বর্ধিত রূপ — yield statement
Haat v1-এ generator নেই। যোগ করতে হলে কী লাগবে? নিচে একটি নকশার খসড়া, “Haat-এর বর্ধিত রূপ” (reference-এ নেই, তাই চালানো যায় না):
// Haat-এর বর্ধিত রূপ: yield (নকশা, reference-এ নেই)
fn slots(start: Int, n: Int) -> Gen(Int) {
var t = start;
var i = 0;
while i < n {
yield t; // statement, print-এর মতো
t = t + 30;
i = i + 1;
}
}
for s in slots(600, 3) { // আরেকটি বর্ধিত রূপ: generator-এর ওপর loop
print(s);
}নকশার সিদ্ধান্তগুলো:
- নতুন type
Gen(T). type checker নিয়ম বানায়:Gen(T)ফেরত দেওয়া function-এর প্রতিটিyield e-এ e : T, আরreturn e;নিষেধ (শুধুreturn;). তাই spec decision 21-এর missing-return নিয়ম এখানে খাটে না। yieldএকটি statement, expression নয়। Haat-এprint(decision 8) আর assignment (decision 9) statement;yield-ও তাই। এর একটি বড় বাস্তবায়ন-সুবিধা নিচে।- ডাকলে body চলে না।
slots(600, 3)শুধু একটি generator মান দেয়।
এবার VM. reference-এর VM-এ (README: “one operand stack shared by all calls and one Frame(closure, ip, slots) per call”) একটি ডাক মানে frame-এর stack-এ একটি নতুন Frame, আর RETURN মানে সেটি ফেলে দেওয়া। generator-এর জন্য দরকার তৃতীয় একটি পথ: frame-টি frame-stack থেকে সরানো, কিন্তু ফেলে না দিয়ে generator object-এ রেখে দেওয়া। yield t;-কে print(t); দিয়ে বদলে reference-এর সত্যিকারের dis নেওয়া হলো, তারপর শুধু PRINT-এর জায়গায় নতুন YIELD বসানো হলো (বাকি সব reference-এর হুবহু; লাফের লক্ষ্য instruction index, decision 28):
| index | নির্দেশ | কাজ |
|---|---|---|
| 0–3 | LOAD_LOCAL 0; STORE_LOCAL 2; CONST 0; STORE_LOCAL 3 | t = start, i = 0 |
| 4–7 | LOAD_LOCAL 3; LOAD_LOCAL 1; LT; JUMP_IF_FALSE 19 | loop-এর শর্ত |
| 8–9 | LOAD_LOCAL 2; YIELD | t বাইরে, frame থামে (ip = 10) |
| 10–17 | … ADD; STORE_LOCAL 2; … ADD; STORE_LOCAL 3 | t = t + 30, i = i + 1 |
| 18 | JUMP 4 | পেছনের লাফ |
| 19–20 | CONST (); RETURN | generator শেষ |
এখানেই statement-এর সুবিধা। reference-এর operand stack সব ডাকের মধ্যে ভাগ করা। yield যদি expression হতো, যেমন print(a + yield t), তবে থামার মুহূর্তে a-র মান operand stack-এ পড়ে থাকত, আর resumer-এর কাজে সেটি চাপা পড়ত বা হারাত; তখন frame-এর সঙ্গে stack-এর সেই টুকরোটিও বাঁচাতে হতো (CPython ঠিক এই কারণেই প্রতিটি frame-কে নিজস্ব value stack দেয়)। statement হলে, yield-এর মান বেরিয়ে যাওয়ার পরে এই frame-এর কোনো মান operand stack-এ থাকে না। তাই বাঁচাতে হয় শুধু ip আর slots: যা Frame-এ আগে থেকেই আছে। একটি ছোট VM-এ এটি বাস্তবায়ন করা অনুশীলন ১-এর কাজ; লেখকের চালানো খসড়া 600, 630, 660 ছাপে, যা print-ওয়ালা রূপের reference run আর vm দুটির সত্যিকারের আউটপুটের সমান।
৬ · Cooperative multitasking — নিজের হাতে একটি event loop
Generator-কে শুধু মানের উৎস হিসেবে না দেখে “থামতে পারা কাজ” হিসেবে দেখলে নতুন একটি দরজা খোলে। কয়েকটি কাজ, প্রতিটি একটি coroutine. একজন পরিচালক (scheduler) পালা করে একেকটিকে চালায়; কাজটি নিজে থামলে (yield) পরিচালক পরেরটি ধরে। একে বলে cooperative multitasking, কারণ নিয়ন্ত্রণ ছাড়ার দায় কাজের নিজের। উল্টো দিকে OS-এর thread চলে preemptive multitasking-এ: timer interrupt যেকোনো নির্দেশের মাঝে thread থামাতে পারে। আর এই পরিচালকই হলো event loop.
নিচের block-এ asyncio নেই, তবু কাজগুলো লেখা হয়েছে async def আর await দিয়ে। কৌশল: Sleep class-এর __await__ একটি generator, যার yield সরাসরি event loop-এর হাতে পৌঁছায়। event loop প্রতিটি কাজকে send(None) দিয়ে চালায়, ঠিক অংশ ২-এর generator-এর মতো। ঘড়ি বাস্তব নয়, tick গোনা, তাই আউটপুট সবসময় এক।
# একটি ছোট event loop: async def task আর নিজের Sleep, asyncio ছাড়াই
import heapq
from collections import deque
class Sleep: # "আমাকে n tick পরে জাগাবেন"
def __init__(self, ticks): self.ticks = ticks
def __await__(self): yield self # await আসলে এখানে yield করে
now = 0 # loop-এর ঘড়ি (tick)
async def cook(orders):
for o in orders:
print(f"t={now} cook: start {o}")
await Sleep(2)
print(f"t={now} cook: {o} ready")
async def rider(trips):
for i in range(trips):
print(f"t={now} rider: trip {i + 1} out")
await Sleep(3)
print(f"t={now} rider: back")
def run(*tasks):
global now
ready, sleeping, seq = deque(tasks), [], 0
while ready or sleeping:
if not ready: # সবাই ঘুমিয়ে: ঘড়ি সামনে নেওয়া
now = sleeping[0][0]
while sleeping and sleeping[0][0] == now:
ready.append(heapq.heappop(sleeping)[2])
task = ready.popleft()
try:
req = task.send(None) # পরের await পর্যন্ত চলবে
seq += 1; heapq.heappush(sleeping, (now + req.ticks, seq, task))
except StopIteration:
print(f"t={now} ({task.__name__} finished)")
c = cook(["BG-101", "BG-102"])
print(type(c).__name__, "object; body not started yet")
run(c, rider(2))আসল আউটপুট (ব্রাউজারের Python):
coroutine object; body not started yet
t=0 cook: start BG-101
t=0 rider: trip 1 out
t=2 cook: BG-101 ready
t=2 cook: start BG-102
t=3 rider: trip 2 out
t=4 cook: BG-102 ready
t=4 (cook finished)
t=6 rider: back
t=6 (rider finished)
প্রথম লাইন: async def ডাকলে generator-এর মতোই body চলে না, একটি coroutine object আসে। তারপর রাঁধুনি আর রাইডারের কাজ এক thread-এ জড়িয়ে চলে। কেউ কাউকে থামায়নি: প্রতিটি পালাবদল ঘটেছে একটি await-এ। asyncio-র আসল event loop-এর মূল কাঠামোও এই: প্রস্তুত কাজের সারি, সময়ের হিসাবে সাজানো ঘুমন্ত কাজ (heap), আর নেটওয়ার্কের জন্য OS-এর select/epoll-জাতীয় অপেক্ষা। পূর্ণ asyncio পাবেন Python কোর্সের পর্ব ৪৫-এ.
1while ready or sleeping:2 if not ready:3 now = সবচেয়ে আগের জাগার সময়4 সেই কাজগুলো ready-তে5 task = ready.popleft()6 req = task.send(None)7 sleeping-এ (now + req.ticks)8 except StopIteration: শেষ
| now | |
| ready | |
| sleeping |
- শুরু। দুটি coroutine ready সারিতে, কেউ ঘুমিয়ে নেই, ঘড়ি 0. কোনো body এখনো চলেনি।
- cook-এর পালা।
send(None): cook প্রথম অর্ডার শুরু করেawait Sleep(2)-এ থামে। loop তাকে “2 tick-এ জাগাতে হবে” তালিকায় রাখে। - rider-এর পালা। প্রথম trip-এ বেরিয়ে
Sleep(3)-এ থামে, জাগবে 3-এ। ready এখন খালি। - ঘড়ি 2-এ। সবাই ঘুমিয়ে, তাই ঘড়ি সরাসরি সবচেয়ে আগের জাগার সময় 2-এ। cook জাগে, BG-101 শেষ, BG-102 শুরু, আবার থামে, জাগবে 4-এ।
- ঘড়ি 3-এ। rider জাগে, দ্বিতীয় trip-এ বেরিয়ে আবার থামে, জাগবে 6-এ।
- ঘড়ি 4-এ। cook জাগে, BG-102 শেষ। অর্ডার ফুরিয়েছে, তাই body শেষ,
sendতোলে StopIteration: cook-এর কাজ সমাপ্ত। - ঘড়ি 6-এ। rider ফিরে আসে, তার body-ও শেষ। ready আর sleeping দুটিই খালি, তাই loop থামে।
আসল asyncio-র সঙ্গে মিলিয়ে নিন: Sleep-এর জায়গায় asyncio.sleep, run-এর জায়গায় asyncio.run, আর প্রতিটি coroutine-কে মুড়ে রাখে একটি Task, যা ঠিক এভাবেই send(None) দিয়ে তাকে এক ধাপ চালায়। asyncio-র Future-এর __await__-ও, ফল তৈরি না হলে, নিজেকেই yield করে, ঠিক উপরের Sleep-এর মতো; Task সেটি ধরে, Future-এ একটি callback বসায়, আর ফল এলে coroutine-কে আবার ready সারিতে তোলে। অর্থাৎ await কোনো জাদু নয়: stackless coroutine-এর একটি yield, যার মান যায় event loop-এর হাতে।
Cooperative ব্যবস্থার দুর্বলতাও এখানে স্পষ্ট। cook যদি await ছাড়া একটি লম্বা হিসাব করত (ধরুন এক কোটি অর্ডারের যোগফল), তবে সেই পুরো সময় rider একটি লাইনও চলত না; event loop-এর হাতে নিয়ন্ত্রণই ফিরত না। তাই asyncio বা Node.js-এ blocking ডাক (যেমন time.sleep, ভারী হিসাব) পুরো server জমিয়ে দেয়। বিনিময়ে লাভ: দুটি await-এর মাঝের কোড কেউ ভাঙতে পারে না, তাই data race-এর বড় একটি অংশ নিজে থেকেই দূর হয় (পর্ব ১১-এ দেখেছেন)।
৭ · async/await — coroutine, event loop আর promise একসাথে
async/await নতুন কোনো যন্ত্র নয়; তিনটি পুরোনো জিনিসের জোড়া: (১) stackless coroutine, যার থামার বিন্দু হলো await; (২) একটি event loop; (৩) “ভবিষ্যতের ফল”-এর একটি object: JavaScript-এ Promise, Python-এ Future/Task, Rust-এ Future. একটি async function প্রথম await পর্যন্ত সাধারণ function-এর মতোই সঙ্গে সঙ্গে চলে; সেখানে থেমে একটি Promise ফেরত দেয়; আর যে Promise-এর জন্য অপেক্ষা, সেটি পূর্ণ হলে বাকি অংশ একটি microtask হিসেবে চলে।
প্রমাণ হিসেবে নিচের block-এ একই কাজ দুইভাবে: ES2017-এর async function, আর ES2015-এর generator সঙ্গে ১০ লাইনের একটি runner, যা প্রতিটি yield হওয়া Promise পূর্ণ হলে generator-কে next(v) দিয়ে আবার চালায়। async আসার আগে লাইব্রেরিগুলো ঠিক এই কৌশলেই async কোড লিখতে দিত।
// async function বনাম generator + ছোট runner: একই ক্রম
const log = [];
const sleep = ms => new Promise(r => setTimeout(r, ms));
async function order(name, ms) { // ES2017
log.push(`${name}: start`);
await sleep(ms); // এখানে function দুই ভাগ হয়
log.push(`${name}: after await`);
return name.length;
}
function* orderGen(name, ms) { // ES2015-এর generator দিয়ে একই কাজ
log.push(`${name}: start`);
yield sleep(ms); // runner promise-এর অপেক্ষা করে
log.push(`${name}: after yield`);
return name.length;
}
function run(gen) { // async-এর আগের যুগের runner
return new Promise((resolve, reject) => {
function step(v) {
const r = gen.next(v);
if (r.done) return resolve(r.value);
Promise.resolve(r.value).then(step, reject);
}
step();
});
}
const p1 = order("chal", 20);
const p2 = run(orderGen("dal", 10));
log.push("main: sync code ends");
Promise.all([p1, p2]).then(v => {
log.push(`results: ${JSON.stringify(v)}`);
console.log(log.join("\n"));
});আসল আউটপুট (ব্রাউজারের JavaScript; লেখকের Node.js 24.15-এও একই):
chal: start
dal: start
main: sync code ends
dal: after yield
chal: after await
results: [4,3]
তিনটি জিনিস লক্ষ করুন। (১) “chal: start” সবার আগে: order(...) ডাকামাত্র body প্রথম await পর্যন্ত চলেছে, অর্থাৎ JavaScript-এর async function প্রথম অংশ সঙ্গে সঙ্গে চালায় (Python-এর async def চালায় না, অংশ ৬-এর প্রথম লাইন দেখুন)। (২) “main: sync code ends” দুই কাজের “after” অংশের আগে: await-এর পরের অংশ বর্তমান কোড শেষ হওয়ার পরেই চলতে পারে। (৩) generator-রূপটি (dal) async-রূপের মতোই আচরণ করেছে; ১০ ms-এর অপেক্ষা আগে শেষ, তাই আগে ফিরেছে। Promise.all ফল দেয় ইনপুটের ক্রমে: [4, 3]. JavaScript-এর দিক থেকে পূর্ণ আলোচনা JavaScript কোর্সের পর্ব ৩৪-এ.
ইতিহাসের ক্রমটিও এই গল্পই বলে। F#-এ ২০০৭ সালের দিকে async workflow আসে; C# 5.0 (২০১২) async/await জোড়াকে মূলধারায় আনে। Python ধাপে ধাপে এগোয়: generator (২০০১), send (PEP 342, Python 2.5), yield from (Python 3.3, ২০১২), asyncio (Python 3.4, ২০১৪), আর async def/await শব্দ (PEP 492, Python 3.5, ২০১৫)। JavaScript-এ generator ES2015-এ, async function ES2017-এ; Rust-এ async/await স্থির হয় 1.39-এ (২০১৯)। প্রতিটি ধাপে নিচের যন্ত্রটি একই: থামতে পারা frame.
দামও আছে। stackless হওয়ায় async কেবল async-এর ভেতর থেকে await করা যায়; একটি গভীর function async হলে তাকে ডাকা সব function-কেও async হতে হয়। Bob Nystrom ২০১৫ সালের একটি লেখায় একে বলেছিলেন function-এর “রঙ”: function coloring. Go-র goroutine আর Java 21-এর virtual thread stackful, তাই সেখানে রঙ নেই: সাধারণ blocking কোড লেখা যায়, runtime নিজেই থামিয়ে অন্য কাজ চালায়। দাম হলো runtime-এর জটিলতা আর প্রতিটি কাজের জন্য বাড়তে পারা stack. ভাষার স্তরে async runtime-এর বিস্তার আসবে পর্ব ৭৭-এ (ভাষার স্তরে concurrency — memory model, data race আর async runtime).
৮ · Continuation আর call/cc — থামার সবচেয়ে সাধারণ রূপ
প্রতিটি মুহূর্তে একটি program-এর সামনে একটি প্রশ্ন থাকে: “এই হিসাব শেষ হলে এরপর কী করতে হবে?” সেই “বাকি হিসাব”-টির নাম continuation. সাধারণত এটি অদৃশ্য: call stack-এর ফেরার ঠিকানাগুলোই এর বাস্তব রূপ। Scheme-এ call/cc (call-with-current-continuation) এই অদৃশ্য জিনিসটিকে একটি সাধারণ মান বানিয়ে হাতে দেয়; সেই মানকে ডাকলে program লাফিয়ে আবার সেই মুহূর্তে ফেরে। নিচে একটি ছোট ব্যবহার, আগেভাগে বেরোনোর জন্য:
;; উদাহরণ (Scheme), চালানো হয়নি
(define (first-big xs limit)
(call/cc
(lambda (return) ; return = "first-big-এর পরের বাকি হিসাব"
(for-each (lambda (x)
(if (> x limit) (return x)))
xs)
#f)))
(first-big '(300 1200 900 1500) 1000) ; => 1200এখানে continuation শুধু একবার, বাইরের দিকে ব্যবহার হয়েছে, ঠিক exception বা break-এর মতো। কিন্তু call/cc-এর মান সংরক্ষণ করে পরে বারবার ডাকা যায়, এমনকি function ফিরে যাওয়ার পরেও। এই ক্ষমতা দিয়ে exception, generator, backtracking, coroutine, সবই একটি ভাষার লাইব্রেরি হিসেবে লেখা যায়। তুলনায় generator হলো একটি সীমিত continuation: শুধু নিজের body-র বাকি অংশ ধরে (delimited), আর প্রতিটি থামা অবস্থা একবারই resume হয় (one-shot). এই সীমার কারণেই generator সস্তা: একটি frame বাঁচালেই চলে, পুরো stack কপি করতে হয় না।
Continuation ধরার আরেকটি পথ হলো program-কেই বদলে লেখা, যাতে প্রতিটি function ফল return না করে “বাকি হিসাব”-এর function-কে ডাকে: continuation-passing style (CPS). পর্ব ১০-এর success continuation আর Node.js-এর callback এরই রূপ। CPS-এ লেখা program-এ প্রতিটি ডাক tail call হয়ে যায়, তাই এটি পরের পর্ব ৩২ (Recursion আর tail call — stack ছাড়া loop)-এর একটি মূল কৌশল। আর Kotlin-এর suspend function compiler ভেতরে ভেতরে CPS-এ নামায়: প্রতিটি suspend function একটি লুকানো continuation parameter পায়।
আরও গভীরে: C-তে ভাষার সাহায্য ছাড়াই stackless coroutine লেখার একটি বিখ্যাত কৌশল আছে: switch-এর case label-কে loop-এর ভেতরে বসিয়ে (Duff's device-এর ধাঁচে) অবস্থা-নম্বর থেকে সরাসরি থামার জায়গায় লাফানো। Simon Tatham-এর “Coroutines in C” লেখা আর Adam Dunkels-এর protothreads (ছোট embedded যন্ত্রের জন্য) এই ধারণা জনপ্রিয় করে; এটি আসলে অংশ ৪-এর state machine, হাতে লেখা macro দিয়ে। উল্টো প্রান্তে OCaml 5 (২০২২) effect handler যোগ করেছে, যা one-shot continuation-এর ওপর দাঁড়িয়ে generator, async আর আরও অনেক কিছু একটি সাধারণ ব্যবস্থায় বাঁধে।
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:
- Subroutine আর coroutine-এর পার্থক্য? subroutine একবার ঢুকে একবার বেরোয়; coroutine বারবার থামে আর থামার জায়গা থেকে চলে, local অবস্থা বাঁচিয়ে।
- Generator কোথায় local variable রাখে? heap-এ রাখা একটি frame বা state object-এ, stack-এ নয়; তাই yield-এর পরেও মান টিকে থাকে।
- Stackless আর stackful coroutine-এর পার্থক্য? stackless শুধু নিজের body-তে থামে (Python, JS, C++20); stackful নিজের stack নিয়ে যেকোনো গভীর ডাক থেকে থামে (Lua, virtual thread).
- async/await কীভাবে বাস্তবায়িত হয়? compiler async function-কে state machine-এ নামায়; await-এ থেমে Promise/Future ফেরত দেয়, আর event loop ফল এলে আবার চালায়।
- Cooperative আর preemptive multitasking? cooperative-এ কাজ নিজে নিয়ন্ত্রণ ছাড়ে (await, yield); preemptive-এ OS timer interrupt দিয়ে জোর করে থামায়।
৯ · AI-এর যুগে generator আর async
Async কোড লেখায় AI assistant খুবই সাহায্য করে, কিন্তু এই বিষয়ের ভুলগুলো চুপচাপ থাকে: কোড চলে, বেশির ভাগ সময় ঠিক উত্তরও দেয়, শুধু চাপের সময় বা বিশেষ ক্রমে ভেঙে পড়ে।
| AI-এর ভুল | কীভাবে ধরবেন |
|---|---|
এক ভাষার নিয়ম অন্য ভাষায়: “Python-এর async def ডাকলেই প্রথম await পর্যন্ত চলে” (এটি JavaScript-এর নিয়ম) | সেই ভাষা আর version-এ ছোট একটি ছাপার probe চালানো |
async-এর ভেতরে blocking ডাক (time.sleep, ভারী loop), ফলে পুরো event loop জমে যায় | দুটি কাজ একসাথে চালিয়ে দেখা যে অন্যটি আটকে যায় কি না; blocking কাজ আলাদা thread বা process-এ |
| await দিতে ভুলে যাওয়া: coroutine কখনো চলেই না, বা Promise-এর ভুল ধরা পড়ে না | Python-এর “never awaited” সতর্কবার্তা পড়া; JS-এ lint নিয়ম আর unhandled rejection-এর test |
| “এই দুই কাজের আউটপুট সবসময় এই ক্রমে আসবে” ধরনের নিশ্চিত দাবি, যখন ক্রম আসলে timer বা নেটওয়ার্কের ওপর নির্ভর করে | নির্ভরশীল ক্রম হলে স্পষ্ট await; ক্রমের test একাধিকবার, ভিন্ন delay-তে চালানো |
| Generator-কে দুবার ঘোরানো বা হাতে নামানো রূপে লুকানো অবস্থা (iterator, temporary) বাদ পড়া | আসল generator আর নতুন রূপ একই ডাকের ক্রমে চালিয়ে মেলানো (differential test) |
AI-কে ভালোভাবে কাজে লাগাতে ভাষা, version আর runtime বলে দিন, আর প্রতিটি দাবির যাচাইয়ের উপায় চান:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১Python আর JavaScript কেন stackless generator বেছে নিল, অথচ Lua stackful coroutine?
দুই পথের মূল পার্থক্য হলো “থামা অবস্থা”-য় কী বাঁচাতে হয়। stackless-এ একটি frame, যার আকার compiler আগে থেকে জানে; stackful-এ একটি পুরো stack, যার গভীরতা আগে থেকে জানা নেই। CPython-এর interpreter নিজেই C-তে লেখা, আর Python থেকে Python function ডাকা বহু বছর ধরে C stack-এর ওপর recursion হিসেবে চলত। এমন অবস্থায় যেকোনো গভীরতা থেকে থামা মানে C stack-এর একটি অংশ কোথাও সরিয়ে রাখা, যা portable C-তে নিরাপদে করা কঠিন। PEP 255 (২০০১) তাই সীমিত কিন্তু নিরাপদ পথ নেয়: শুধু generator-এর নিজের frame থামবে। JavaScript engine-গুলোও একই কারণে, আর web-এর সব engine-এ একই আচরণ নিশ্চিত করতে, ES2015-এ stackless generator নেয়।
Lua-র নকশাকাররা উল্টো সিদ্ধান্ত নেন। Lua 5.0 (২০০৩) থেকে coroutine stackful আর asymmetric: যেকোনো গভীর Lua function থেকে coroutine.yield করা যায়। de Moura আর Ierusalimschy তাদের প্রবন্ধে যুক্তি দেন যে এমন “পূর্ণ” coroutine দিয়ে generator, cooperative thread, এমনকি one-shot continuation-ও বানানো যায়, তাই ভাষায় একটি ব্যবস্থাই যথেষ্ট। Lua-র interpreter-এর নিজস্ব stack আছে (C stack নয়), তাই প্রতিটি coroutine-কে আলাদা Lua stack দেওয়া তুলনামূলক সস্তা। তবু সীমা থেকে যায়: একটি C function-এর মাঝখান দিয়ে yield করা সহজ নয়, আর পরের সংস্করণে এর জন্য বিশেষ continuation-ভিত্তিক API যোগ করতে হয়েছে।
দুই পথের ব্যবহারিক ফল পরিষ্কার। stackless-এ প্রতিটি থামার বিন্দু কোডে লেখা থাকে (yield, await), তাই পাঠক জানেন কোথায় অন্য কাজ ঢুকে পড়তে পারে; কিন্তু “রঙ” ছড়ায়, আর লাইব্রেরি দুবার লিখতে হয় (sync আর async). stackful-এ সাধারণ কোড অপরিবর্তিত থাকে, কিন্তু থামার জায়গা অদৃশ্য, আর প্রতিটি কাজের stack-এর জন্য মেমরি লাগে। Java 21-এর virtual thread দেখায় যে runtime যথেষ্ট পরিণত হলে stackful পথও লাখো কাজে সম্ভব: থামার সময় stack-এর দরকারি অংশ heap-এ কপি হয়।
মূল উপলব্ধি: stackless বনাম stackful মূলত বাস্তবায়নের সীমা থেকে আসা নকশার সিদ্ধান্ত; একটি দেয় সস্তা, দৃশ্যমান থামার বিন্দু, অন্যটি দেয় অদৃশ্য কিন্তু সর্বত্র থামার স্বাধীনতা।
প্র ০২“Function-এর রঙ” কেন বড় সমস্যা, আর ভাষাগুলো একে কীভাবে সামলাচ্ছে?
Bob Nystrom ২০১৫ সালে “What Color is Your Function?” নামের একটি লেখায় একটি কাল্পনিক ভাষা কল্পনা করেন: সব function লাল বা নীল; লাল function শুধু লাল function থেকে ডাকা যায়, আর লালটি ডাকার নিয়মও কঠিন। এটি আসলে async-এর বর্ণনা। stackless coroutine শুধু নিজের body-তে থামতে পারে, তাই যে function একটি await করবে, তাকে async হতে হবে; তাকে যে ডাকবে, তাকেও await করতে হবে, অর্থাৎ async হতে হবে। একটি গভীর helper-এ নেটওয়ার্কের ডাক যোগ হলে রঙ ওপরে ছড়িয়ে পড়ে পুরো ডাকের শিকলে।
বাস্তব দাম কয়েক রকম। লাইব্রেরি দুবার লিখতে হয় বা দুটি API রাখতে হয় (Python-এ একই HTTP কাজের sync আর async রূপ)। sync কোড থেকে async ডাকা কঠিন, আর async-এর ভেতর থেকে blocking sync ডাক event loop জমিয়ে দেয়। callback বা higher-order function (যেমন map) async function পেলে প্রত্যাশামতো কাজ করে না, কারণ তারা Promise-এর অপেক্ষা করে না।
ভাষাগুলো তিন রকম উত্তর দিয়েছে। প্রথম, রঙ মেনে নিয়ে tooling দিয়ে সহজ করা: JavaScript, Python, C#, Rust এই পথে, কারণ দৃশ্যমান await পাঠককে বলে কোথায় অন্য কাজ ঢুকতে পারে, আর runtime ছোট থাকে। দ্বিতীয়, stackful runtime দিয়ে রঙ মুছে ফেলা: Go শুরু থেকেই goroutine দিয়ে, আর Java ২১ virtual thread দিয়ে; সেখানে সাধারণ blocking কোড লেখা হয়, runtime নিজে থামিয়ে অন্য কাজে যায়। তৃতীয়, effect handler বা algebraic effect-এর মতো গবেষণার পথ, যেখানে “থামতে পারে” তথ্যটি type-এ থাকে কিন্তু কোড দুবার লিখতে হয় না; OCaml 5 এর একটি বাস্তব রূপ দেয়।
কোনো পথ বিনামূল্যে নয়। stackful runtime-এ কোন লাইনে কাজ বদলাতে পারে তা কোডে দেখা যায় না, তাই shared data-র জন্য আবার lock লাগে। রঙওয়ালা পথে সেই নিশ্চয়তা আছে, কিন্তু কোড ভাগ হয়ে যায়।
মূল উপলব্ধি: function-এর রঙ stackless coroutine-এর সরাসরি ফল; ভাষা হয় রঙকে দৃশ্যমান নিরাপত্তা হিসেবে রাখে, নয়তো ভারী runtime দিয়ে মুছে দেয়, আর দুই পথেই একটি জিনিস হারায়।
প্র ০৩Conway-র ১৯৬৩ সালের compiler-এ lexer আর parser coroutine ছিল। আজকের compiler-এ (যেমন Haat-এর) এই সম্পর্ক কেমন?
Conway-র সমস্যা ছিল তখনকার যন্ত্রের: মেমরি খুব কম, আর COBOL program-এর পুরো token তালিকা একসাথে রাখার জায়গা নেই। তাঁর সমাধান: lexer আর parser দুটি সমান অংশীদার, যারা পালা করে চলে। lexer একটি token বানিয়ে parser-কে নিয়ন্ত্রণ দেয়; parser সেটি ব্যবহার করে আরেকটি চাইলে lexer যেখানে থেমেছিল সেখান থেকে চলে। কেউ কারও subroutine নয়, দুজনেরই নিজস্ব “কোথায় আছি” অবস্থা। এটিই coroutine-এর প্রথম প্রকাশিত ব্যবহারগুলোর একটি, আর Unix-এর pipe-এর ধারণার সঙ্গেও এর মিল আছে: একটির output অন্যটির input, দুটির মাঝে ছোট একটি বাফার।
আজকের বেশির ভাগ হাতে লেখা compiler-এ এই সম্পর্ক asymmetric হয়ে গেছে: parser মালিক, lexer সেবক। parser next_token() ডাকে, আর lexer একটি সাধারণ object যার ভেতরে অবস্থান (কোন অক্ষর পর্যন্ত পড়া হয়েছে) field হিসেবে থাকে। অর্থাৎ lexer-এর coroutine-অবস্থা হাতে একটি state object-এ নামানো হয়েছে, ঠিক এই পর্বের অংশ ৪-এর মতো। Haat-এর reference আরও সরল পথ নিয়েছে: পুরো source একবারে token তালিকায় বদলায় (tokenize()), কারণ আজ মেমরি সমস্যা নয়, আর তালিকা থাকলে parser সহজে সামনে তাকাতে পারে। এর বিস্তার পর্ব ৪৬-এ (হাতে লেখা lexer — Haat-এর token, position আর error).
তবু coroutine-রূপটি হারায়নি। Python-এ lexer-কে generator হিসেবে লেখা খুব স্বাভাবিক: yield Token(...) লিখলেই অবস্থান-রাখার ঝামেলা compiler নেয়। Python-এর নিজের tokenize module একটি generator দেয়। বড় file বা নেটওয়ার্ক থেকে আসা ডেটার জন্য, যেখানে পুরোটা একসাথে রাখা যায় না, এই ধাঁচ আজও সেরা। আর IDE-র language server-এ, যেখানে প্রতিটি টাইপের পরে আংশিক লেখা আবার পড়তে হয়, থামতে আর চলতে পারা lexer কাজে লাগে।
মূল উপলব্ধি: coroutine জন্মেছিল compiler-এর ভেতরে; আজ একই সম্পর্ক কখনো state object, কখনো generator, কখনো পুরো তালিকা, প্রয়োজন আর মেমরির মাপে বেছে নেওয়া হয়।
প্র ০৪নেটওয়ার্ক server-এ async/await কেন thread-প্রতি-অনুরোধ মডেলকে অনেক জায়গায় সরিয়ে দিল?
১৯৯৯ সালে Dan Kegel “C10K problem” নামে একটি প্রশ্ন তোলেন: একটি যন্ত্রে দশ হাজার সংযোগ একসাথে কীভাবে সামলানো যায়? প্রতিটি সংযোগে একটি OS thread দিলে প্রতিটির নিজস্ব stack (প্রায়ই কয়েকশো KB থেকে কয়েক MB পর্যন্ত সংরক্ষিত ঠিকানা-জায়গা), আর হাজারো thread-এর মধ্যে kernel-এর পালাবদলের খরচ। অথচ বেশির ভাগ সংযোগ বেশির ভাগ সময় শুধু অপেক্ষা করছে: database-এর উত্তর, client-এর পরের বাইট। অপেক্ষার জন্য পুরো একটি thread আটকে রাখা অপচয়।
উত্তর এল event-ভিত্তিক server থেকে: একটি thread, OS-এর select, poll, পরে epoll-এর মতো ব্যবস্থায় “কোন সংযোগ প্রস্তুত” জেনে শুধু সেগুলোর কাজ করে। কিন্তু হাতে লেখা event-ভিত্তিক কোড মানে প্রতিটি অনুরোধকে টুকরো টুকরো callback-এ ভাঙা, আর অনুরোধের অবস্থা হাতে একটি object-এ বয়ে বেড়ানো: অর্থাৎ হাতে লেখা state machine. Node.js (২০০৯) এই মডেল জনপ্রিয় করে, আর “callback hell” শব্দও।
async/await এই দুই জগতের সেতু। প্রোগ্রামার সোজা ক্রমে লেখেন, যেন thread-এর blocking কোড; compiler সেই কোডকে state machine-এ নামায় (অংশ ৪); আর event loop একটি বা অল্প কয়েকটি thread-এ হাজারো থেমে থাকা কাজ ধরে রাখে, প্রতিটির দাম শুধু একটি ছোট heap object. C# 5.0 (২০১২) এই মডেলকে মূলধারায় আনে, পরে Python, JavaScript, Rust একই পথ নেয়।
তবে এটি সর্বজয়ী নয়। CPU-ভারী কাজে async কোনো সুবিধা দেয় না, কারণ সেখানে অপেক্ষা নেই, আর একটি ভারী হিসাব event loop জমিয়ে দেয়। stack trace ভেঙে যায়, কারণ থামা কাজের “ডাকা-পক্ষ” stack-এ নেই; runtime-গুলোকে আলাদা করে async stack trace তৈরি করতে হয়েছে। আর Java 21-এর virtual thread দেখাচ্ছে যে thread-প্রতি-অনুরোধ মডেলও সস্তা thread পেলে ফিরে আসতে পারে।
মূল উপলব্ধি: async/await জিতেছে কারণ এটি event-ভিত্তিক server-এর কার্যকারিতা আর ক্রমিক কোড সহজে পড়ার সুবিধা একসাথে দেয়; এর মূল্য হলো cooperative নিয়মের শৃঙ্খলা আর ভেঙে যাওয়া stack trace.
প্র ০৫call/cc এত শক্তিশালী হলে মূলধারার ভাষাগুলো কেন পূর্ণ first-class continuation দেয় না?
Continuation-এর ধারণা ১৯৬০-এর দশকে কয়েকজন প্রায় স্বাধীনভাবে আবিষ্কার করেন; John Reynolds ১৯৯৩ সালে “The Discoveries of Continuations” প্রবন্ধে এই ইতিহাস লেখেন। Scheme continuation-কে ভাষার কেন্দ্রে আনে, আর call/cc বহু দশক ধরে তার standard-এ আছে। একটি primitive থেকে exception, generator, coroutine, backtracking সবই লাইব্রেরি হিসেবে লেখা যায়: ভাষা-নকশার দিক থেকে এটি আকর্ষণীয় সরলতা।
সমস্যা তিনটি। প্রথম, খরচ: পূর্ণ continuation মানে যেকোনো মুহূর্তের পুরো stack ধরে রাখা আর পরে বারবার পুনরায় চালু করা। হয় stack কপি করতে হয়, নয় সব frame heap-এ রাখতে হয়, যা সাধারণ function call-কেও ধীর করতে পারে। দ্বিতীয়, resource-এর সঙ্গে সংঘাত: একটি function ফাইল খুলে finally-তে বন্ধ করল; এখন তার ভেতরের একটি continuation পরে আবার ডাকলে program আবার ফাইল-খোলা অবস্থায় “ফিরে” আসে, অথচ ফাইল বন্ধ। Scheme এর জন্য dynamic-wind রেখেছে, কিন্তু তাতে জটিলতা বাড়ে। তৃতীয়, বোঝার কঠিনতা: call/cc দিয়ে লেখা কোড অবাধ goto-র মতো যেকোনো জায়গায় লাফ দিতে পারে। Oleg Kiselyov-এর মতো গবেষকরা যুক্তি দিয়েছেন যে undelimited call/cc নিজেই একটি দুর্বল primitive, আর delimited (সীমিত) continuation ভালো বিকল্প।
তাই মূলধারার ভাষাগুলো continuation-এর নির্দিষ্ট, সীমিত রূপগুলোই নিয়েছে: exception (একবার, শুধু বাইরের দিকে), generator আর async (একটি frame-এর, one-shot), আর stackful runtime-এর ভেতরে লুকানো continuation (Java-র virtual thread অভ্যন্তরে এরকম একটি ব্যবস্থা ব্যবহার করে বলে প্রকাশিত নকশায় বলা হয়েছে)। OCaml 5-এর effect handler এই দুই জগতের মাঝে: delimited আর one-shot, তবু এক ব্যবস্থায় অনেক কিছু প্রকাশ করা যায়।
মূল উপলব্ধি: continuation হলো control flow-এর সবচেয়ে সাধারণ ধারণা, আর ঠিক সেই সাধারণতাই তাকে দামি ও বিপজ্জনক করে; বাস্তব ভাষা তাই সীমিত, সস্তা রূপগুলো বেছে নেয়।
অনুশীলন
প্রথমে নিজে হিসাব করুন বা লিখুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর সত্যিকারের run দিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — Haat-এর বর্ধিত রূপে YIELD: একটি ছোট stack VM লিখুন (Frame-এ
code,ip,slots; একটি ভাগ করা operand stack), যেখানে তিনটি নতুন নির্দেশ আছে:CALL_GEN(generator function-এর জন্য body না চালিয়ে একটি generator object বানায়),FOR_GEN t(stack-এর মাথার generator চালু করে; সেটি শেষ হলে generator সরিয়ে t-তে লাফ) আরYIELD. অংশ ৫-এর slots-এর bytecode (index 0–20) চালিয়ে 600, 630, 660 ছাপুন।# Haat-এর বর্ধিত রূপ: মূল তিনটি নির্দেশ (নকশার খসড়া, reference-এ নেই) class Gen: def __init__(self, frame): self.frame, self.done = frame, False # … run() loop-এর ভেতরে, বাকি নির্দেশ আগের মতো … elif op == "CALL_GEN": # body চলে না: শুধু frame তৈরি args = [stack.pop() for _ in range(arg[1])][::-1] stack.append(Gen(Frame(gens[arg[0]], args))) elif op == "FOR_GEN": # gen চালু করা, শেষ হলে arg-এ লাফ g = stack[-1] if g.done: stack.pop(); f.ip = arg else: f.ip -= 1; frames.append(g.frame) # ফিরে এসে আবার FOR_GEN elif op == "YIELD": # frame সরানো, কিন্তু ফেলে না দেওয়া v = stack.pop(); frames.pop() caller = frames[-1]; caller.ip += 1 # FOR_GEN-এর পরে stack.append(v) elif op == "RETURN": # gen-এর শেষ stack.pop(); frames.pop(); stack[-1].done = Truemain-এর কোড:
CONST 600; CONST 3; CALL_GEN slots/2; FOR_GEN 8; STORE_LOCAL 0; LOAD_LOCAL 0; PRINT; JUMP 3; HALT. লেখকের CPython 3.14.4-এ পূর্ণ VM (৩৬ লাইন) চালানো হলো: আউটপুট600,630,660, আর শেষে operand stack খালি ([])। মূল ভাবনা:YIELDframe-টিকে frame-stack থেকে সরায় কিন্তু Gen object-এ রেখে দেয়, তাই পরেরFOR_GENসেই একই Frame (একইipআরslots) আবার চাপিয়ে দিলে loop ঠিক পরের নির্দেশ থেকে চলে।FOR_GEN-এip -= 1একটি কৌশল: generator শেষ হলে নিয়ন্ত্রণ আবারFOR_GEN-এ ফেরে, যাdoneদেখে লাফ দেয়।yieldstatement বলে yield-এর মুহূর্তে operand stack-এ এই frame-এর কিছুই থাকে না, তাই আলাদা করে stack বাঁচাতে হয়নি। Haat-এর আসল ধাঁচে ডাকা-পক্ষের ভুল ব্যবহার (শেষ generator-কে আবার ঘোরানো) হলে runtime error দেওয়া যেত, যেমনgenerator already finished. -
ভুল খুঁজুন — হাতে নামানো state machine: একজন অংশ ৪-এর
BillSMলিখলেন, শুধু state 0-তেself.itনা বানিয়েsend-এর loop লিখলেনfor price in self.items:. বাকি সব একই।[400, 0, 250, 300]দিয়েnext,send(50),next,nextডাকলে কী ফল আসবে, আর ভুলটি ঠিক কোথায়?সত্যিকারের run (CPython 3.14.4):
[400, 750, 1150, 1550]; আসল generator দেয়[400, 600, 900]আর তারপরStopIteration(900). প্রথম ডাক ঠিক: 400. দ্বিতীয় ডাকে total = 400 − 50 = 350, কিন্তুfor price in self.itemsপ্রতিবার একটি নতুন iterator বানায়, তাই loop আবার 400 থেকে শুরু: 350 + 400 = 750. এরপর প্রতিবার 400 যোগ হয়, আর generator কখনো শেষই হয় না, কারণ প্রতিটি ডাক প্রথম জিনিসেই return করে।ভুলটি নিয়ম ২-এ: yield পেরিয়ে যে অবস্থা বাঁচে, তার সবকিছু field হতে হবে, লুকানো অবস্থাও। for-loop-এর iterator কোডে কোনো নামে দেখা যায় না, কিন্তু সেটি loop-এর “কোথায় আছি”-র পুরো তথ্য। CPython-এর
dis-এ সেটি value stack-এ বসে থাকে (GET_ITER,FOR_ITER), তাই frame বাঁচালেই বাঁচে। হাতে নামাতে হলে একেself.itবানাতে হয়। আসল compiler একই কারণে প্রতিটি yield-বিন্দুতে কোন temporary জীবিত, তা হিসাব করে (liveness, পর্ব ৬৪)। ধরার উপায়: আসল generator আর নতুন রূপ একই ডাকের ক্রমে চালিয়ে মেলানো। -
আউটপুট আগে বলুন — send, close আর finally (Python 3.14):
def g(): try: x = yield 1 print("got", x) yield x * 2 print("never") finally: print("cleanup") it = g() print(next(it)) print(it.send(5)) it.close() print("after close")1 got 5 10 cleanup after closeসত্যিকারের run (CPython 3.14.4).
nextপ্রথম yield পর্যন্ত চালায়, তাই1.send(5)-এ x = 5, “got 5” ছাপা হয়, তারপর দ্বিতীয় yield দেয়10. এখনclose(): Python থেমে থাকা yield-এর জায়গায় একটিGeneratorExitexception ঢোকায়। সেটি try থেকে বেরোনোর পথেfinallyচালায়, তাই “cleanup”; “never” কখনো ছাপা হয় না। generator-এরfinallyতাই গ্যারান্টি দেয় না যে body শেষ পর্যন্ত চলবে, শুধু এটুকু যে বন্ধ হলে পরিষ্কারের কাজ হবে।close()না ডাকলেও CPython-এ generator object মুছে যাওয়ার সময় একই কাজ হয়, কিন্তু কখন, তা garbage collection-এর ওপর নির্ভর করে। -
Trace — JavaScript-এর await-এর ক্রম: নিচের program কোন ক্রমে ছাপবে? প্রতিটি লাইনের পাশে কারণ লিখুন।
async function a() { console.log("a1"); await null; console.log("a2"); } async function b() { console.log("b1"); await a(); console.log("b2"); } b(); console.log("main"); Promise.resolve().then(() => console.log("then"));সত্যিকারের run (Node.js 24.15):
b1,a1,main,a2,then,b2.b()সঙ্গে সঙ্গে চলে:b1. তারপরa()ডাকে, সেটিও সঙ্গে সঙ্গে:a1.a-রawait null: null একটি পূর্ণ Promise-এ মোড়ানো হয়, আর a-র বাকি অংশ microtask সারিতে যায়। a একটি অপূর্ণ Promise ফেরত দেয়; b সেটির জন্য await করে থামে।- sync কোড চলতে থাকে:
main. তারপরthen-এর callback microtask সারিতে, a-র বাকি অংশের পেছনে। - সারির প্রথম কাজ: a-র বাকি অংশ,
a2. a শেষ, তার Promise পূর্ণ; b-এর বাকি অংশ এখন সারিতে ঢোকে, কিন্তু “then”-এর পেছনে। then, তারপরb2.
শিক্ষা: await-এর পরের অংশ এমন একটি কাজ, যা সারিতে নিজের পালার অপেক্ষা করে; দুই স্তরের await মানে সারিতে অন্তত দুটি পালা। এমন সূক্ষ্ম ক্রমের ওপর কোডের সঠিকতা নির্ভর করানো বিপজ্জনক; ক্রম জরুরি হলে স্পষ্ট await দিয়ে বেঁধে দিন।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি compiler একটি generator function-কে state machine-এ নামানোর কাজগুলো যে ক্রমে করে, সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- body-র প্রতিটি yield-বিন্দু খুঁজে একটি করে অবস্থা-নম্বর দেওয়া
- yield পেরিয়ে বাঁচা local variable আর লুকানো temporary-কে object-এর field বানানো
- function ডাকলে body না চালিয়ে অবস্থা 0-সহ object ফেরত দেওয়া
- resume হলে অবস্থা-নম্বর দেখে সঠিক জায়গায় লাফ (switch)
- প্রতিটি yield-এ পরের অবস্থা-নম্বর লিখে মান return করা
- body শেষে “শেষ” অবস্থা লিখে থামার সংকেত দেওয়া
Python 3.14-এ def slots(n): function-এর body-তে একটি print("start") আর তারপর একটি yield আছে। g = slots(3) লেখার পরে কী ঘটে?
- "start" ছাপা হয়, তারপর প্রথম yield-এ থামে
- কিছু ছাপা হয় না; একটি generator object তৈরি হয়
- TypeError, কারণ generator ডাকতে হয় next() দিয়ে
- body পুরো চলে, সব মানের একটি তালিকা g-তে আসে
একটি stackless coroutine (যেমন Python-এর generator) সম্পর্কে কোন কথাটি সত্য?
- প্রতিটি generator নিজের আলাদা পুরো stack পায়
- ভেতর থেকে ডাকা যেকোনো সাধারণ function-এর ভেতর থেকেও yield করা যায়
- শুধু নিজের body-তে থামতে পারে; গভীরে থামাতে প্রতিটি স্তরে yield from লাগে
- প্রতিটি generator একটি আলাদা OS thread-এ চলে
একটি compiler generator-কে state machine-এ নামানোর সময় যে local variable একটি yield পেরিয়ে ব্যবহার হয়, সেটি কোথায় রাখে?
- heap-এ থাকা state object বা frame-এর field-এ
- method-এর সাধারণ stack frame-এ
- একটি global variable-এ
- CPU register-এ
JavaScript-এ (Node.js 24) এই program কোন ক্রমে ছাপে? async function f() { console.log(1); await null; console.log(3); } f(); console.log(2);
- 1, 3, 2
- 2, 1, 3
- 2, 3, 1
- 1, 2, 3
একটি asyncio server-এর একটি async handler-এ কেউ await ছাড়া একটি ভারী loop লিখলেন, যা ৩ সেকেন্ড CPU খায়। অন্য client-দের কী হয়?
- event loop handler-টিকে মাঝপথে থামিয়ে অন্যদের চালায়
- ওই ৩ সেকেন্ড অন্য সব client-এর অনুরোধ আটকে থাকে
- asyncio ভারী loop-টিকে নিজে থেকে আলাদা thread-এ পাঠায়
- Python একটি error তুলে handler বন্ধ করে
Python-এর generator-কে কেন semi-coroutine (asymmetric) বলা হয়?
- কারণ সে মাত্র একবার থামতে পারে
- কারণ তাকে বাইরে থেকে কোনো মান দেওয়া যায় না
- কারণ yield করলে নিয়ন্ত্রণ সবসময় তাকে যে চালিয়েছে তার কাছেই ফেরে
- কারণ তার নিজের পুরো stack আছে
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Coroutine = থামতে পারা function: থামার জায়গা আর local variable বাঁচিয়ে রাখে, তাই frame-এর আয়ু ডাকের সঙ্গে নয়, coroutine object-এর সঙ্গে বাঁধা।
- Generator: ডাকলে body চলে না;
next/sendপরের yield পর্যন্ত চালায়; শেষে StopIteration, যার value-তে return-এর মান। - দুই প্রশ্নে শ্রেণিভাগ: থামলে কোথায় ফেরে (semi বনাম symmetric), আর কত গভীর থেকে থামা যায় (stackless বনাম stackful).
- State machine-এ নামানো: yield-বিন্দু = অবস্থা-নম্বর, বাঁচা variable (লুকানো iterator-সহ) = field, resume = অবস্থা দেখে লাফ। Haat-এ yield statement হলে বাঁচাতে হয় শুধু ip আর slots.
- async/await = coroutine + event loop + Promise/Future: cooperative, তাই blocking কাজ সবাইকে আটকায়; আর সবকিছুর মূলে continuation-এর ধারণা।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ৩২ · Recursion আর tail call — stack ছাড়া loopপরবর্তী পর্বtail call, trampoline আর CPS.
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্বপুরো কোর্সের মানচিত্র আর Haat প্রজেক্টের পথ।
- পর্ব ১১ · Concurrent programming-এর মডেলএই কোর্সেthread, actor, CSP আর JavaScript-এর event loop.
- asyncio — এক thread-এ অনেক অপেক্ষা, async আর awaitপাশের ট্র্যাকPython-এর event loop, Task আর await হাতে-কলমে।
- async/await — promise-এর কোড সহজে লেখা আর ভুল সামলানোপাশের ট্র্যাকJavaScript-এর async function পুরোটা।
- async, future আর atomics — পেছনে কাজ, পরে ফলপাশের ট্র্যাকfuture, promise আর thread-এর দিক থেকে একই প্রশ্ন।