এই পর্বে যা শিখবেন
- RTOS-এর task-গুলোর মধ্যে ভাগ করা সম্পদ চিনে critical section ঠিক করা
- Binary আর counting semaphore দিয়ে সংকেত দেওয়া আর সম্পদ গোনা, আর কোথায় সংকেত হারায়
- Mutex আর semaphore-এর পার্থক্য: মালিকানা, priority inheritance, ISR-এ ব্যবহার
- Priority inversion tick ধরে ব্যাখ্যা করা, আর priority inheritance ও ceiling-এর প্রভাব মাপা
- Blocking time যোগ করে response-time analysis, আর দুই mutex-এর deadlock চেনা ও ঠেকানো
১ · ভাগ করা সম্পদ — একাধিক task, একটি UART
পর্ব ৫৬-এ আপনি দেখেছেন, একটি RTOS কয়েকটি task-কে priority অনুযায়ী পালা করে CPU দেয়, আর উঁচু task এলে নিচুটিকে মাঝপথে থামায় (preemption). এই ক্ষমতারই একটি দাম আছে: task-গুলো যদি একই জিনিস ব্যবহার করে, যেমন একটি UART, একটি I2C bus, একটি global struct বা একটি buffer, তাহলে একজনের কাজের মাঝখানে আরেকজন ঢুকে পড়তে পারে। এই পর্বে hex লেখা হবে C-ধাঁচে, 0x….
ISR আর main loop-এর মধ্যে একই সমস্যা আপনি আগেই দেখেছেন: পর্ব ৩৪-এ volatile আর অবিভাজ্যতা, পর্ব ৩৫-এ register-এর read-modify-write, আর পর্ব ৪৩-এ interrupt বন্ধ রেখে critical section. সেখানে সমাধান ছিল কয়েক নির্দেশের জন্য interrupt বন্ধ রাখা। Task-এর স্তরে কাজ অনেক লম্বা হতে পারে, একটি পুরো লাইন ছাপা বা একটি I2C লেনদেন, তাই পুরো সময় interrupt বন্ধ রাখা চলে না। দরকার এমন একটি তালা, যার জন্য অপেক্ষারত task ঘুমায় আর অন্যরা চলতে থাকে। সাধারণ OS-এর দৃষ্টিতে race condition-এর তত্ত্ব আছে Operating Systems পর্ব ২২-এ; এখানে আমরা RTOS আর বাজারঘরের যন্ত্রের দিকটি দেখব।
উপমা — পাড়ার একটি মাইক: মসজিদ বা স্কুলের একটিমাত্র মাইকে দুজন একসাথে ঘোষণা দিলে কারও কথাই বোঝা যায় না। নিয়ম হলো, যে মাইক হাতে নিয়েছে, ঘোষণা শেষ করে নামিয়ে রাখার আগে অন্য কেউ ধরবে না। মাইকটি mutex, ঘোষণাটি critical section. আর জরুরি ঘোষণা নিয়ে কেউ এলে তাঁকেও আগের ঘোষণা শেষ হওয়া পর্যন্ত দাঁড়াতে হয়: তালার দাম অপেক্ষা।
বাজারঘরের cold-storage monitor-এ ধরুন দুটি task একই UART-এ লেখে। SEN (priority 1) প্রতি 1 s-এ t=7 s T=+9.50 C লাইন ছাপে; TEL (priority 2) প্রতি 10 s-এ telemetry. নিচের ব্লকে প্রতি tick-এ UART-এ একটি অক্ষর যায়, আর tick 6-এ TEL এসে SEN-কে preempt করে। একবার তালা ছাড়া, একবার পুরো লাইনের জন্য mutex নিয়ে:
# দুটি task একই UART-এ লেখে; প্রতি tick-এ একটি অক্ষর যায়।
# SEN (priority 1) লাইন লিখছে, tick 6-এ TEL (priority 2) এসে preempt করে।
def run(use_lock):
tasks = {"SEN": [1, 0, "t=7 s T=+9.50 C\n"], # priority, release, text
"TEL": [2, 6, "TELEMETRY seq=1\n"]}
pos = {n: 0 for n in tasks}
owner, uart, t, done = None, "", 0, {}
while any(pos[n] < len(tasks[n][2]) for n in tasks):
ready = [n for n in tasks if tasks[n][1] <= t and pos[n] < len(tasks[n][2])]
if use_lock: # mutex: যার হাতে তালা নেই সে অপেক্ষায়
ready = [n for n in ready if owner in (None, n)]
if ready:
n = max(ready, key=lambda k: tasks[k][0]) # বড় priority আগে
if use_lock and owner is None:
owner = n # লাইনের প্রথম অক্ষরে lock
uart += tasks[n][2][pos[n]]
pos[n] += 1
if pos[n] == len(tasks[n][2]):
owner = None # পুরো লাইন শেষে unlock
done[n] = t + 1
t += 1
return uart, done
for lock in (False, True):
text, done = run(lock)
print("mutex" if lock else "lock নেই", f"(SEN শেষ {done['SEN']}, TEL শেষ {done['TEL']}):")
print(text, end="")আসল আউটপুট (ব্রাউজারের Python):
lock নেই (SEN শেষ 32, TEL শেষ 22):
t=7 s TELEMETRY seq=1
T=+9.50 C
mutex (SEN শেষ 16, TEL শেষ 32):
t=7 s T=+9.50 C
TELEMETRY seq=1
তালা ছাড়া TEL দ্রুত শেষ হয় (tick 22), কিন্তু dashboard-এর parser পায় t=7 s TELEMETRY seq=1: দুটি লাইনই নষ্ট। Mutex দিলে দুটি লাইন অক্ষত, কিন্তু TEL-কে SEN-এর লাইন শেষ হওয়া পর্যন্ত, tick 6 থেকে 16, অপেক্ষা করতে হয়েছে, যদিও TEL-এর priority বেশি। এই অপেক্ষার নাম blocking: নিচু task-এর ধরা তালার জন্য উঁচু task-এর দেরি। Blocking অনিবার্য; নকশার কাজ হলো তাকে ছোট আর সীমিত রাখা। পুরো পর্বটি এই একটি বাক্যের বিস্তার।
মূল নিয়ম প্রতিটি ভাগ করা সম্পদের জন্য লিখে রাখুন: কোন কোন task এটি ছোঁয়, কোন তালা এটি রক্ষা করে, আর তালা সর্বোচ্চ কতক্ষণ ধরা থাকে। শেষ সংখ্যাটিই পরে উঁচু task-এর blocking time হবে।
২ · Semaphore — সংকেত দেওয়া আর গোনা
Semaphore একটি গণনা আর অপেক্ষার সারি। দুটি কাজ: take (মান 0-এর বেশি হলে এক কমানো, নইলে ঘুম) আর give (কেউ ঘুমিয়ে থাকলে তাকে জাগানো, নইলে মান এক বাড়ানো). ধারণাটি Edsger Dijkstra-র, ১৯৬০-এর দশকের মাঝামাঝি; তাঁর P আর V নামের ব্যাখ্যা সূত্রভেদে একটু আলাদা, তাই সেটি OS কোর্সের পর্ব ২৪-এ দেখে নিন। RTOS-এ এর দুটি রূপ প্রধান:
Binary semaphore
মান শুধু 0 বা 1. সাধারণ ব্যবহার সংকেত: একটি ISR বা task “ঘটনা ঘটেছে” জানায়, অপেক্ষারত task জাগে। এর নাম binary semaphore.
Counting semaphore
মান 0 থেকে একটি সর্বোচ্চ পর্যন্ত। কয়েকটি একই রকম সম্পদ গোনা (দুটি TX buffer), বা না-সামলানো ঘটনা জমিয়ে রাখা। এর নাম counting semaphore.
RTOS simulator-এ — binary semaphore ঘটনা হারায়
কোর্সের reference lab-এর rtos_sim.py পূর্ণ tick-এ চলে, প্রতি tick-এ একটি task (Spec decision 32: বড় priority সংখ্যা বেশি জরুরি, FreeRTOS-এর মতো). Simulator-এ interrupt নেই, তাই ISR-কে সবচেয়ে উঁচু priority-র একটি task হিসেবে রাখলাম: সে পরপর তিনবার rdy give করে, আর LOG task প্রতিটি সংকেতে একবার কাজ করতে চায়। দুটি scenario, পার্থক্য শুধু max: 1 (binary) বনাম 3 (counting). Give আর take শূন্য সময়ের কাজ, শুধু compute সময় নেয় (Spec decision 33).
সত্যিকারের run — python -B rtos_sim.py run sem_bin.json (reference lab, Python 3.13.5)
0 ISR ISR released; LOG released; ISR gives rdy (count now 1)
1 ISR ISR gives rdy (already at max 1, lost)
2 LOG ISR gives rdy (already at max 1, lost); ISR finishes (response 2); LOG takes rdy (count now 0)
3 idle LOG blocks on rdy
ISR ##......
LOG --#BBBBB
সত্যিকারের run — python -B rtos_sim.py run sem_cnt.json
1 ISR ISR gives rdy (count now 2)
2 LOG ISR gives rdy (count now 3); ISR finishes (response 2); LOG takes rdy (count now 2)
3 LOG LOG takes rdy (count now 1)
4 LOG LOG takes rdy (count now 0); (end of tick) LOG finishes (response 5)
LOG --###...
Binary semaphore-এ দ্বিতীয় আর তৃতীয় সংকেত lost: মান আগেই 1, আর বাড়তে পারে না। LOG একবার কাজ করে tick 3 থেকে চিরকাল অপেক্ষায় (Gantt-এ B). Counting semaphore তিনটি ঘটনাই জমিয়ে রাখে, LOG তিনবার চলে, শেষ 5-এ। শিক্ষা: binary semaphore বলে “অন্তত একবার ঘটেছে”, কতবার তা নয়। Button চাপ জানাতে এটি যথেষ্ট; কিন্তু UART-এ আসা প্রতিটি byte গুনতে নয়, সেখানে counting semaphore বা queue (পর্ব ৫৮) লাগে। সংকেত হারানোর এই সমস্যাটি সাধারণ OS-এর lost wakeup-এর আত্মীয়।
Counting semaphore-এর দ্বিতীয় ব্যবহার সম্পদের ভাণ্ডার। আমার lab-এর pool.json-এ buf শুরু হয় 2 দিয়ে (দুটি MQTT TX buffer), আর A, B, C তিনটি task প্রত্যেকে একটি buffer নিয়ে 3 tick কাজ করে। সত্যিকারের run-এ A tick 0-এ নেয় (count now 1), A শেষে ফেরত দেয়, B নেয়, তারপর C; সবার response 3, 6, 9. লক্ষ্য করুন, simulator-এ প্রতি tick-এ একটিই task চলে বলে এখানে দুটি buffer একসাথে ব্যবহার হয়নি; take-এর পর task যখন DMA বা UART-এর অপেক্ষায় ঘুমায়, তখনই দ্বিতীয় buffer কাজে লাগে।
ISR-এ শুধু “FromISR” API: FreeRTOS-এ ISR থেকে semaphore দিতে xSemaphoreGiveFromISR(), সাধারণ xSemaphoreGive() নয়; আর ISR কখনো take করে অপেক্ষা করতে পারে না, কারণ ISR ঘুমাতে পারে না। Cortex-M port-এ এমন ISR-এর NVIC priority-ও একটি সীমার ভেতরে রাখতে হয় (configMAX_SYSCALL_INTERRUPT_PRIORITY; NVIC-এর priority-র সংখ্যা পর্ব ৩০-এ). ISR-এ কাজ ছোট রেখে বাকিটা task-এ পাঠানোর নকশাকে বলে deferred interrupt handling.
৩ · Mutex বনাম semaphore — মালিকানাই পার্থক্য
মান 1 দিয়ে শুরু করা binary semaphore দেখতে তালার মতোই: take মানে ঢোকা, give মানে বের হওয়া। তাহলে আলাদা mutex কেন? কারণ semaphore-এর কোনো মালিক নেই। যে কেউ give করতে পারে, এমনকি যে take করেনি সেও। নিচের দুটি run একই ভুল দেখায়: A তালা ধরে কাজ করছে, B (যে তালা নেয়নি) ভুল করে ছেড়ে দেয়:
সত্যিকারের run — rtos_sim.py run nonowner.json (S একটি mutex)
error: B unlocks S it does not own
সত্যিকারের run — rtos_sim.py run nonowner_sem.json (S একটি semaphore, count 1)
0 A A released; A takes S (count now 0)
1 B B released; B gives S (count now 1); B preempts A; (end of tick) B finishes (response 1)
2 C C released; C takes S (count now 0)
3 A C gives S (count now 1); C finishes (response 1)
5 idle A gives S (already at max 1, lost); A finishes (response 5)
Mutex-এ simulator ভুলটি সঙ্গে সঙ্গে ধরে (Spec decision 35: শুধু মালিক unlock করতে পারে). Semaphore-এ কোনো অভিযোগ নেই, অথচ tick 2-এ C ঢুকে পড়েছে যখন A তখনো তার critical section-এর মাঝে: mutual exclusion ভেঙে গেছে, চুপচাপ। আসল firmware-এ এমন bug মাসে একবার একটি নষ্ট লাইন হয়ে দেখা দেয়।
| বৈশিষ্ট্য | Mutex | Semaphore |
|---|---|---|
| উদ্দেশ্য | তালা: একটি সম্পদ একবারে একজন | সংকেত, বা n-টি সম্পদ গোনা |
| মালিক | আছে; শুধু মালিক ছাড়তে পারে | নেই; যে কেউ give করতে পারে |
| Priority inheritance | সম্ভব, কারণ জানা আছে কাকে উঁচু করতে হবে | সাধারণত নয়; FreeRTOS-এর binary semaphore-এ নেই |
| ISR থেকে | না (FreeRTOS-এ mutex ISR-এ চলে না) | give করা যায় (…FromISR), take নয় |
| একই task দুবার নিলে | সাধারণ mutex-এ নিজেই আটকে যায়; recursive mutex-এ চলে | মান কমে; 0 হলে আটকে যায় |
| বাজারঘরে উদাহরণ | UART বা I2C bus-এর তালা | sensor-এর ALERT pin-এর ISR থেকে task-কে জাগানো |
যে mutex একই মালিক কয়েকবার নিতে পারে, যতবার নেয় ততবার ছাড়ে, তার নাম recursive mutex (FreeRTOS-এ xSemaphoreCreateRecursiveMutex()). এটি দরকার হয় যখন একটি তালা-ধরা ফাংশন আরেকটি তালা-ধরা ফাংশন ডাকে; তবে অনেক নকশাকার একে নকশার দুর্বলতার লক্ষণ মনে করেন, আর কোড এমনভাবে সাজান যাতে তালা একবারই নেওয়া হয়। Reference simulator-এর mutex recursive নয়: একই task দুবার lock করলে ত্রুটি দেখায় (Spec decision 35).
৪ · Priority inversion — মাঝারি task উঁচুটিকে আটকায়
তালা দিলে উঁচু task-কে কিছুক্ষণ অপেক্ষা করতে হয়, এটুকু মেনে নেওয়া যায়: নিচু task-এর critical section ছোট হলে অপেক্ষাও ছোট। বিপদ আসে তৃতীয় একজনের কারণে। পর্ব ০৬-এ lab-এর পরিচয়ে আপনি এর এক ঝলক দেখেছেন; এখন tick ধরে পুরোটা।
Reference lab-এর ক্লাসিক scenario (README, inversion.json): L (priority 1) tick 0-এ এসে S ধরে, 4 tick কাজ করে, S ছাড়ে, আরও 1 tick. H (priority 3) tick 2-এ আসে: 1 tick কাজ, তারপর S চায়, 2 tick কাজ, S ছাড়ে। M (priority 2) tick 4-এ আসে, 6 tick কাজ করে; S-এর সঙ্গে তার কোনো সম্পর্ক নেই।
সত্যিকারের run — python -B rtos_sim.py demo inversion (reference lab)
scheduler: preemptive fixed priority; mutex S: no inheritance
tick run events
0 L L released; L locks S
2 H H released; H preempts L
3 L H blocks on S (owner L)
4 M M released; M preempts L
9 M (end of tick) M finishes (response 6)
10 L
11 H L unlocks S -> H gets it; H preempts L
13 L H unlocks S; H finishes (response 11); (end of tick) L finishes (response 14)
0 1
0123456789012345
H ..#BBBBBBBB##...
M ....######......
L ##-#------#--#..
| সময় (tick) | |
| CPU-তে | |
| S-এর মালিক | |
| H | |
| M | |
| L | |
| H-এর অপেক্ষা |
- L তালা ধরে। Tick 0-এ L আসে, S নেয় (শূন্য সময়ে), tick 0 আর 1 চলে। এখনো সব স্বাভাবিক।
- H আসে, L-কে preempt করে। Tick 2-এ H-এর প্রথম কাজ S লাগে না, তাই সে সরাসরি চলে। L ready অবস্থায়, S তখনো তার হাতে।
- H তালায় আটকায়। Tick 3-এ H S চায়; মালিক L, তাই H blocked. CPU ফেরে L-এর কাছে। এটুকু প্রত্যাশিত, সীমিত blocking: L-এর বাকি 2 tick.
- M ঢুকে পড়ে। Tick 4-এ M আসে। M-এর priority 2, L-এর 1, তাই M L-কে সরিয়ে টানা 6 tick চলে। H-এর priority সবচেয়ে বেশি, অথচ H অপেক্ষা করছে M-এর জন্য, যে S ছোঁয়ই না। এটিই priority inversion.
- M শেষে L আবার চলে। Tick 10-এ L তার S-এর শেষ tick চালায়। H-এর অপেক্ষা ততক্ষণে 8 tick, যার 6 tick M-এর কাজ।
- S হাতবদল। Tick 11-এর শুরুতে L S ছাড়ে; ownership সরাসরি অপেক্ষমাণ H-এর কাছে যায় (Spec decision 35), H L-কে preempt করে tick 11 আর 12 চলে।
- ফল। H শেষ 13-এ, response 11. H-এর নিজের কাজ মাত্র 3 tick. M যদি 6-এর বদলে 60 tick চলত, বা আরও কয়েকটি মাঝারি task থাকত, H-এর অপেক্ষার কোনো ওপরের সীমা থাকত না।
শেষ caption-এর কথাটিই আসল বিপদ। L-এর critical section-এর জন্য অপেক্ষা সীমিত (bounded), কিন্তু মাঝারি task-দের কাজ যোগ হলে অপেক্ষা হয়ে যায় unbounded priority inversion: H-এর সবচেয়ে খারাপ response আর L বা H-এর কোডের ওপর নির্ভর করে না, নির্ভর করে এমন task-দের ওপর যাদের সঙ্গে H-এর কোনো সম্পর্কই নেই। Real-time-এর প্রতিশ্রুতি (পর্ব ৫৪) এখানেই ভাঙে।
একটি প্রশ্ন স্বাভাবিক: mutex-এর বদলে binary semaphore দিলে কী হয়? আমার lab-এর inv_sem.json একই scenario, S একটি semaphore (count 1). সত্যিকারের run-এর Gantt হুবহু একই: H ..#BBBBBBBB##..., H-এর response 11. Semaphore-এর মালিক নেই, তাই simulator কাকে উঁচু করবে জানে না; FreeRTOS-এর binary semaphore-ও inheritance দেয় না।
৫ · প্রতিকার — priority inheritance আর priority ceiling
সমাধানের ভাবনা সরল: H যখন L-এর তালার জন্য অপেক্ষা করছে, তখন L আসলে H-এর হয়ে কাজ করছে। তাই সেই সময়টুকু L-কে H-এর priority দিন। এর নাম priority inheritance. Scenario-তে S-এর জন্য "inherit": true:
সত্যিকারের run — python -B rtos_sim.py demo inversion --inherit
scheduler: preemptive fixed priority; mutex S: priority inheritance
3 L H blocks on S (owner L); L inherits priority 3
4 L M released
5 H L unlocks S -> H gets it; H preempts L
7 M H unlocks S; H finishes (response 5)
12 M (end of tick) M finishes (response 9)
13 L (end of tick) L finishes (response 14)
H ..#BB##.........
M ....---######...
L ##-##--------#..
| সময় (tick) | |
| CPU-তে | |
| L-এর কার্যকর priority | |
| S-এর মালিক | |
| M | |
| H | |
| ফল |
- শুরু একই। L S ধরে tick 0 আর 1 চলে, তার priority 1.
- H আসে, চলে। Tick 2-এ H L-কে preempt করে, আগের মতোই।
- H আটকায়, L উঁচু হয়। Tick 3-এ H S চায়, blocked. Simulator লেখে “L inherits priority 3”: যতক্ষণ L S ধরে, তার কার্যকর priority H-এর সমান।
- M এল, কিন্তু ঢুকতে পারল না। Tick 4-এ M আসে, priority 2. L এখন 3, তাই M ready অবস্থায় অপেক্ষা করে (Gantt-এ
-). Inversion-এর দরজা বন্ধ। - L S ছাড়ে, নিজের priority-তে ফেরে। Tick 5-এর শুরুতে L unlock করে, S সরাসরি H-এর কাছে যায়, L আবার 1. H tick 5 আর 6 চলে। H-এর blocking মোট 2 tick (3 আর 4): ঠিক L-এর critical section-এর বাকি অংশ।
- H শেষ, M চলে। H শেষ 7-এ, response 5 (আগে 11). M এবার tick 7 থেকে 12 চলে, response 9 (আগে 6).
- খরচ কার ঘাড়ে। M-এর response 3 tick বেড়েছে: সে L-এর critical section-এর জন্য অপেক্ষা করেছে, যদিও S ছোঁয় না। এটি সীমিত, জানা blocking, যা হিসাবে ধরা যায় (নিচে). L-এর response 14 দুই run-এই একই।
ছবি ৫৭.১ — একই তিনটি task, দুই নীতি: H-এর response 11 বনাম 5 tick
rtos_sim.py-এর দুটি সত্যিকারের run-এর Gantt chart থেকে আঁকা, tick 0 থেকে 13
Priority ceiling — তালা ধরার মুহূর্তেই উঁচু
দ্বিতীয় পরিবারের প্রতিকার আগে থেকে হিসাব করে। প্রতিটি mutex-এর একটি ceiling: যত task এটি কখনো নেয়, তাদের সর্বোচ্চ priority. সবচেয়ে সরল রূপে (immediate ceiling, অনেক জায়গায় “highest locker” নামে) task তালা ধরামাত্র ceiling-এ উঠে যায়, কারও অপেক্ষার জন্য বসে থাকে না। Sha, Rajkumar আর Lehoczky ১৯৯০ সালে IEEE Transactions on Computers-এ priority inheritance আর priority ceiling protocol দুটিই বিশ্লেষণ করেন; ceiling-এর মূল protocol-টি এই সরল রূপের চেয়ে সূক্ষ্ম, আর নানা RTOS ও মানদণ্ড (POSIX-এর PTHREAD_PRIO_PROTECT, Ada-র ceiling locking) ভিন্ন ভিন্ন রূপ দেয়, তাই ব্যবহারের আগে নির্দিষ্ট RTOS-এর নথি দেখে নিন। Reference simulator ceiling মডেল করে না; তাই নিচের ব্লক ক্লাসিক scenario-টি একটি ছোট Python simulator-এ তিন নীতিতে চালায়, আর প্রথম দুটি সারি rtos_sim.py-এর run-এর সঙ্গে মিলিয়ে নেওয়া যায়:
# ক্লাসিক দৃশ্য, তিন নীতি: none; inherit (মালিক অপেক্ষমাণের priority পায়);
# ceiling (S ধরলেই মালিক S-এর ceiling = 3 পায়). (priority, release, script)
TASKS = {"L": (1, 0, ["lock", 4, "unlock", 1]), "M": (2, 4, [6]),
"H": (3, 2, [1, "lock", 2, "unlock"])}
def simulate(policy):
pc, left = {n: 0 for n in TASKS}, {n: 0 for n in TASKS}
owner, waiter, gantt, fin = None, None, {n: "" for n in TASKS}, {}
def prio(n):
p = TASKS[n][0]
if n == owner and policy == "inherit" and waiter: p = TASKS[waiter][0]
if n == owner and policy == "ceiling": p = 3
return (p, -TASKS[n][1]) # সমান হলে আগে আসা task আগে
for t in range(14):
run = None
while run is None:
ready = [n for n in TASKS if TASKS[n][1] <= t and n not in fin and n != waiter]
if not ready: break
n = max(ready, key=prio)
a = TASKS[n][2][pc[n]] if pc[n] < len(TASKS[n][2]) else None
if a is None: fin[n] = t
elif a == "lock" and owner is None: owner = n; pc[n] += 1
elif a == "lock": waiter = n
elif a == "unlock":
pc[n] += 1; owner, waiter = waiter, None
if owner: pc[owner] += 1 # অপেক্ষমাণ সরাসরি তালা পায়
else: left[n] = left[n] or a; run = n
if run:
left[run] -= 1; pc[run] += left[run] == 0
for n in TASKS:
gantt[n] += "#" if n == run else "B" if n == waiter else (
"-" if TASKS[n][1] <= t and n not in fin else ".")
return gantt, {n: fin.get(n, 14) - TASKS[n][1] for n in TASKS}
for policy in ("none", "inherit", "ceiling"):
g, r = simulate(policy)
print(policy + ":", " ".join(f"{n} {g[n]} R={r[n]}" for n in "HML"))আসল আউটপুট (ব্রাউজারের Python):
none: H ..#BBBBBBBB##. R=11 M ....######.... R=6 L ##-#------#--# R=14
inherit: H ..#BB##....... R=5 M ....---######. R=9 L ##-##--------# R=14
ceiling: H ..--###....... R=5 M ....---######. R=9 L ####---------# R=14
none আর inherit-এর Gantt rtos_sim.py-এর run-এর প্রথম 14 tick-এর সঙ্গে অক্ষরে অক্ষরে মেলে, তাই ছোট simulator-টিকে বিশ্বাস করা যায়। ceiling-এ ছবিটি আলাদা: L tick 0-এ S ধরতেই 3-এ ওঠে, তাই tick 2-এ আসা H L-কে preempt করতে পারে না (সমান priority-তে আগে আসা L এগিয়ে, এই block-এর নিয়মে), ready অবস্থায় অপেক্ষা করে (--), আর কখনো blocked হয় না। H-এর response তবু 5, inheritance-এর সমান। পার্থক্য সময়ে নয়, গুণে: ceiling-এ H একবার চলতে শুরু করলে আর কোনো তালায় আটকায় না, আর একই ceiling নিয়মে তালার চক্র, মানে deadlock, তৈরি হতে পারে না (অংশ ৬). দাম হলো, L তালা ধরলেই সব মাঝারি task অপেক্ষা করে, H না এলেও।
শিকলের মতো inheritance
Inheritance-কে transitive হতে হয়। আমার lab-এর chain.json: L (1) S1 ধরে 4 tick; M (2) S2 ধরে তারপর S1 চায়; H (4) S2 চায়; X (3) tick 3-এ এসে 5 tick কাজ করে, কোনো তালা ছোঁয় না। H অপেক্ষা করছে M-এর জন্য, M অপেক্ষা করছে L-এর জন্য: L-কে H-এর priority-তে তুলতে হবে, শুধু M-এর নয়।
সত্যিকারের run — rtos_sim.py run chain_pi.json (দুটি mutex-এই inheritance)
1 L M released; M locks S2; M blocks on S1 (owner L); L inherits priority 2
2 L H released; H blocks on S2 (owner M); M inherits priority 4
3 L X released
4 M L unlocks S1 -> M gets it; M preempts L
5 H M unlocks S1; M unlocks S2 -> H gets it; H preempts M
H ..BBB#..........
X ...---#####.....
H released 2 start 5 finish 6 response 4
Tick 3-এ X ready (-) অথচ L চলছে: L-এর কার্যকর priority তখন 4, H থেকে M হয়ে আসা (Spec decision 35: “transitively”). Inheritance না দিলে (chain.json) X tick 3 থেকে 7 পর্যন্ত চলে, আর H-এর response 9. শিকল যত লম্বা, H-এর blocking তত বেশি তালার যোগফল; তাই নকশায় একটি তালা ধরে আরেকটি চাওয়া যত কম, তত ভালো।
Blocking-এর হিসাব — response-time analysis-এ B
পর্ব ৫৬-এর response-time analysis-এ R = C + Σ⌈R/Tj⌉Cj, যোগফল উঁচু সব task-এর ওপর। তালা থাকলে একটি পদ যোগ হয়: Ri = Ci + Bi + Σ⌈Ri/Tj⌉Cj, যেখানে Bi হলো blocking time: নিচু task-এর একটি critical section-এর জন্য সর্বোচ্চ অপেক্ষা। Priority inheritance-এ, প্রতিটি task একটিই তালা নিলে, Bi হলো নিচু task-দের সেই critical section-গুলোর সবচেয়ে লম্বাটি, যাদের তালা i বা তার ওপরের কেউ ব্যবহার করে। এই সংজ্ঞা একটি সরলীকরণ; একাধিক তালা থাকলে inheritance-এ B কয়েকটি critical section-এর যোগফল হতে পারে, ceiling-এ সর্বোচ্চ একটি।
Cold room-এর তিনটি task, tick এককে: ALM (alarm-এর সিদ্ধান্ত, C = 2, T = 10, I2C তালা ধরে 1 tick), CTL (কম্প্রেসর নিয়ন্ত্রণ, C = 3, T = 15, তালা নেই), TEL (telemetry, C = 4, T = 40, I2C তালা ধরে 2 tick). প্রথমে simulator-এ, একটি খারাপ phase-এ: TEL tick 0-এ I2C ধরে, ALM আর CTL tick 1-এ আসে।
সত্যিকারের run — rtos_sim.py run blk.json --no-trace (inheritance ছাড়া)
ALM .BBBB##....##........##........##.......
CTL .###............###............--###....
TEL #---#--##...............................
ALM released 1 start 5 finish 7 response 6 deadline 11 met
সত্যিকারের run — rtos_sim.py run blk_pi.json --no-trace (inheritance-সহ)
ALM .B##.......##........##........##.......
CTL .---###.........###............--###....
TEL ##-----##...............................
ALM released 1 start 2 finish 4 response 3 deadline 11 met
CTL released 1 start 4 finish 7 response 6 deadline 16 met
TEL released 0 start 0 finish 9 response 9 deadline 40 met
from math import ceil
# cold room-এর তিনটি task (tick): (নাম, C, T, I2C ধরে কত tick)
tasks = [("ALM", 2, 10, 1), ("CTL", 3, 15, 0), ("TEL", 4, 40, 2)] # উঁচু থেকে নিচু
def blocking(i):
"""Priority inheritance: নিচু কোনো task-এর একটি critical section-এর
সর্বোচ্চ দৈর্ঘ্য, যদি সেই mutex উঁচু কেউ (i বা তার ওপরের) ব্যবহার করে।"""
uses_above = any(cs > 0 for _, _, _, cs in tasks[: i + 1])
lower = [cs for _, _, _, cs in tasks[i + 1:]]
return max(lower, default=0) if uses_above else 0
def rta(i):
name, c, t, _ = tasks[i]
b, r, steps = blocking(i), c, [c]
while True:
nxt = c + b + sum(ceil(r / tj) * cj for _, cj, tj, _ in tasks[:i])
steps.append(nxt)
if nxt == r or nxt > t:
return b, nxt, steps
r = nxt
seen = {"ALM": 3, "CTL": 6, "TEL": 9} # rtos_sim (inheritance)-এ সর্বোচ্চ দেখা
for i, (name, c, t, _) in enumerate(tasks):
b, r, steps = rta(i)
ok = "OK" if r <= t else "MISS"
print(f"{name}: B={b} R: {' -> '.join(map(str, steps))} "
f"R={r} ≤ T={t} {ok}; simulator-এ দেখা {seen[name]}")
cs, c_ctl = 2, 3
print(f"inheritance ছাড়া ALM-এর blocking: {cs} + CTL-এর {c_ctl} = {cs + c_ctl}"
f" (আরও মাঝারি task থাকলে আরও বাড়ে); simulator-এ ALM R = 6")আসল আউটপুট (ব্রাউজারের Python):
ALM: B=2 R: 2 -> 4 -> 4 R=4 ≤ T=10 OK; simulator-এ দেখা 3
CTL: B=2 R: 3 -> 7 -> 7 R=7 ≤ T=15 OK; simulator-এ দেখা 6
TEL: B=0 R: 4 -> 9 -> 9 R=9 ≤ T=40 OK; simulator-এ দেখা 9
inheritance ছাড়া ALM-এর blocking: 2 + CTL-এর 3 = 5 (আরও মাঝারি task থাকলে আরও বাড়ে); simulator-এ ALM R = 6
তিনটি পর্যবেক্ষণ। এক, CTL কোনো তালা ছোঁয় না, তবু তার B = 2: TEL যখন ALM-এর priority ধার করে চলে, CTL-কেও অপেক্ষা করতে হয় (simulator-এ CTL-এর response inheritance-সহ 6, ছাড়া 3). এর নাম push-through blocking. দুই, ALM-এর সীমা 4, simulator-এ 3: TEL tick 0-এ তালা ধরে এক tick চালিয়ে ফেলেছিল বলে বাকি ছিল 1 tick. এই tick-এর মডেলে সবচেয়ে খারাপ phase-এ পৌঁছানো যায় না; সূত্রটি নিরাপদ ওপরের সীমা, সবসময় হুবহু নয়। TEL-এর 9 অবশ্য হুবহু মিলেছে। তিন, inheritance ছাড়া ALM-এর অপেক্ষা CTL-এর পুরো কাজ গিলে নিয়েছে (simulator-এ 6); সেখানে B-এর কোনো নির্দিষ্ট সীমাই নেই, কারণ যত মাঝারি task, তত দেরি।
৬ · Mars Pathfinder, ১৯৯৭ — মঙ্গলে priority inversion
এই পর্বের সবচেয়ে বিখ্যাত বাস্তব ঘটনা। NASA-র Mars Pathfinder ১৯৯৭ সালের ৪ জুলাই মঙ্গলে নামে; software চলত Wind River-এর VxWorks RTOS-এ। প্রকাশিত বিবরণ অনুযায়ী (ডিসেম্বর ১৯৯৭-এ IEEE Real-Time Systems Symposium-এ David Wilner-এর বক্তৃতার একটি সারসংক্ষেপ, আর তার উত্তরে flight software দলের Glenn Reeves-এর বিস্তারিত চিঠি), নামার কিছুদিন পর, আবহাওয়ার data সংগ্রহ শুরু হওয়ার পর, মহাকাশযানটি বারবার পুরো system reset করতে থাকে।
Reeves-এর বিবরণে ঘটনাটি এমন: একটি shared “information bus”-এ data আদান-প্রদান হতো, আর একটি mutex semaphore তা রক্ষা করত। উঁচু priority-র একটি bus-বিতরণ task (bc_dist) প্রায়ই চলত; কম priority-র একটি আবহাওয়া-data task (ASI/MET) মাঝে মাঝে সেই mutex ধরত। ASI/MET তালা ধরা অবস্থায় মাঝারি priority-র কয়েকটি task চলতে শুরু করলে bc_dist তালার অপেক্ষায় আটকে থাকত। আরেকটি task (bc_sched) প্রতি চক্রে দেখত bc_dist তার কাজ শেষ করেছে কি না; না করলে তাকে গুরুতর ব্যর্থতা ধরে computer reset করত, অনেকটা একটি watchdog-এর মতো। অর্থাৎ অংশ ৪-এর L, M, H, আর H-এর deadline পাহারায় একজন প্রহরী।
JPL-এর প্রকৌশলীরা পৃথিবীতে রাখা একটি প্রতিরূপে VxWorks-এর trace চালু রেখে সমস্যাটি আবার ঘটান আর trace থেকে inversion খুঁজে পান। সমাধান: ওই mutex-এ priority inheritance চালু করা, যা শুরুতে বন্ধ ছিল। Reeves লেখেন, সেটি একটি global configuration variable দিয়ে নিয়ন্ত্রিত হতো, তাই পরিবর্তন শুধু সেই একটি semaphore-এ নয়, ওই ধরনের সব semaphore-এ প্রযোজ্য হয়েছিল, আর বিশ্লেষণ ও পরীক্ষার পর দল তা মেনে নেয়। পরিবর্তনটি পৃথিবী থেকে patch হিসেবে পাঠানো হয়। সারসংক্ষেপে বলা হয়েছিল patch-টি VxWorks-এর C interpreter দিয়ে বসানো হয়; Reeves-এর চিঠি সেটি সংশোধন করে বলে, মহাকাশযানের নিজস্ব patch ব্যবস্থা (অনেক যাচাইসহ) ব্যবহার হয়েছিল। এমন খুঁটিনাটিতে সূত্রভেদে পার্থক্য আছে, তাই মূল চিঠিটি পড়ে নেওয়াই ভালো। Reeves আরও জানান, launch-এর আগে পরীক্ষায় reset দেখা গিয়েছিল কিন্তু আবার ঘটানো যায়নি, আর পরীক্ষা মূলত “সেরা ক্ষেত্রের” data হারে হয়েছিল। ভাবনার প্রশ্ন ১-এ এর শিক্ষা।
৭ · Deadlock — দুটি তালা, উল্টো ক্রম
তালা থেকে আসে আরেকটি বিপদ, যা priority-র সঙ্গে সম্পর্কহীন। বাজারঘরের cold room-এ ধরুন দুটি তালা: I2C (sensor bus) আর UART. SEN (priority 2) আগে I2C ধরে reading নেয়, তারপর UART ধরে ছাপে, দুটি একসাথে ধরে রেখে। TEL (priority 3) আগে UART ধরে লাইন শুরু করে, তারপর তাজা reading-এর জন্য I2C চায়। একটি deadlock-এর সব উপাদান হাজির; OS-এর দৃষ্টিতে পুরো তত্ত্ব (চার শর্ত, ঠেকানো, এড়ানো, ধরা) আছে Operating Systems পর্ব ২৭-এ।
সত্যিকারের run — python -B rtos_sim.py run deadlock.json
scheduler: preemptive fixed priority; mutex I2C: no inheritance, UART: no inheritance
tick run events
0 SEN SEN released; SEN locks I2C
1 TEL TEL released; TEL locks UART; TEL preempts SEN
2 SEN TEL blocks on I2C (owner SEN)
3 idle SEN blocks on UART (owner TEL); DEADLOCK: SEN -> TEL -> SEN
TEL .#BB
SEN #-#B
DEADLOCK at t=3: ['SEN', 'TEL']
| সময় (tick) | |
| CPU-তে | |
| I2C-এর মালিক | |
| UART-এর মালিক | |
| Wait-for | |
| ফল |
- SEN I2C ধরে। Tick 0-এ SEN আসে, I2C নেয়, reading-এর প্রথম tick চালায়।
- TEL UART ধরে। Tick 1-এ TEL আসে, বেশি priority নিয়ে SEN-কে preempt করে, UART নেয়, তার প্রথম tick চলে।
- TEL I2C চায়। Tick 2-এ TEL-এর পরের কাজ I2C নেওয়া; মালিক SEN, তাই TEL blocked. SEN আবার চলে, reading-এর দ্বিতীয় tick. Wait-for graph-এ একটি তীর: TEL → SEN.
- SEN UART চায়: চক্র। Tick 3-এ SEN UART চায়; মালিক TEL. দ্বিতীয় তীর SEN → TEL. চক্র তৈরি, আর চালানোর মতো কেউ নেই: simulator লেখে
DEADLOCK: SEN -> TEL -> SENআর থামে (Spec decision 35). - Inheritance এখানে অসহায়।
deadlock_pi.json-এ দুটি তালায় inheritance: tick 2-এ “SEN inherits priority 3”, কিন্তু tick 3-এ একই চক্র, একই DEADLOCK. Priority বাড়ালে CPU পাওয়া যায়, তালা নয়। - সমাধান: সবাই একই ক্রমে।
ordered.json-এ TEL-ও আগে I2C, তারপর UART নেয়। Tick 1-এ TEL I2C-তেই আটকায়, কোনো তালা না ধরে; SEN দুটি নিয়ে কাজ শেষ করে ছাড়ে, তারপর TEL. TEL-এর response 4, SEN-এর 5, deadlock নেই।
শেষ ধাপের নিয়মটির নাম lock ordering: সব তালার একটি স্থায়ী ক্রম, আর সবাই সেই ক্রমে নেয়। তাহলে circular wait অসম্ভব। বাজারঘরের firmware-এ নিয়মটি এক লাইনে লেখা যায়: “I2C সবসময় UART-এর আগে”। তার চেয়েও ভালো নকশা প্রায়ই সম্ভব: দুটি তালা একসাথে না ধরা। SEN I2C ছেড়ে দিয়ে তারপর UART নিতে পারে, কারণ reading তখন একটি local variable-এ। আরেকটি বাস্তব সুরক্ষা হলো তালা চাওয়ায় সময়সীমা (FreeRTOS-এ xSemaphoreTake-এর দ্বিতীয় argument): সময় পেরোলে task ত্রুটি গুনে আর ধরা তালা ছেড়ে দেয়, চিরকাল আটকে থাকে না। সময়সীমা deadlock ঠেকায় না, শুধু তাকে ধরা পড়ার মতো একটি ত্রুটিতে বদলায়।
৮ · FreeRTOS-এ cold room — সব নিয়ম একসাথে
কোর্সের virtual বাজারঘর board (BG-M3, আসল কোনো পণ্য নয়, Cortex-M3-এর আদলে বানানো) শুধু bare-metal firmware চালায়; PendSV আর PSP মডেল করা হয়নি (Spec decisions 19–21), তাই আসল RTOS এতে চলে না। নিচের কোড FreeRTOS-এর (MIT licence) API-তে একটি নকশা দেখায়; API-র নামগুলো FreeRTOS kernel-এর semphr.h থেকে মিলিয়ে নেওয়া, তবে এটি উদাহরণ, চালানো হয়নি। i2c_read_temp(), uart_puts() আর check_limits() কাল্পনিক ফাংশন।
/* FreeRTOS-এর API — উদাহরণ, চালানো হয়নি */
static SemaphoreHandle_t i2c_mtx, uart_mtx, alert_sem;
static uint32_t lock_timeouts;
void app_init(void)
{
i2c_mtx = xSemaphoreCreateMutex(); /* priority inheritance-সহ */
uart_mtx = xSemaphoreCreateMutex();
alert_sem = xSemaphoreCreateBinary(); /* শুরুতে খালি */
}
void SENSOR_ALERT_IRQHandler(void) /* কাল্পনিক: sensor-এর ALERT pin */
{
BaseType_t woken = pdFALSE;
/* ... interrupt flag মোছা ... */
xSemaphoreGiveFromISR(alert_sem, &woken); /* ISR-এ mutex নয় */
portYIELD_FROM_ISR(woken);
}
void sensor_task(void *arg)
{
for (;;) {
xSemaphoreTake(alert_sem, pdMS_TO_TICKS(1000)); /* ALERT বা 1 s */
if (xSemaphoreTake(i2c_mtx, pdMS_TO_TICKS(20)) != pdTRUE) {
lock_timeouts++; /* তালা পাইনি: গুনে পরের চক্রে */
continue;
}
int16_t t16 = i2c_read_temp(0x48); /* critical section: শুধু পড়া */
xSemaphoreGive(i2c_mtx); /* UART নেওয়ার আগেই ছাড়া */
check_limits(t16); /* তালার বাইরে সিদ্ধান্ত */
if (xSemaphoreTake(uart_mtx, pdMS_TO_TICKS(20)) == pdTRUE) {
uart_puts("t=... T=...\n");
xSemaphoreGive(uart_mtx);
}
}
}নকশার সিদ্ধান্তগুলো এই পর্বের প্রতিটি অংশ থেকে এসেছে। তালা হিসেবে mutex, যাতে inheritance পাওয়া যায় (অংশ ৫); ISR থেকে binary semaphore, কারণ mutex ISR-এ চলে না (অংশ ৩). I2C ছেড়ে তবেই UART, তাই দুটি তালা কখনো একসাথে ধরা হয় না আর deadlock-এর চক্রই সম্ভব নয় (অংশ ৭). Critical section-এ শুধু পড়া, সিদ্ধান্ত বাইরে, যাতে B ছোট থাকে। প্রতিটি take-এ সময়সীমা, আর সময় পেরোলে একটি counter, যা পরীক্ষায় আর মাঠে দেখা যায়। আর alert_sem binary, কারণ এখানে “অন্তত একবার ALERT এসেছে” জানাই যথেষ্ট (অংশ ২); প্রতিটি ঘটনা গোনা দরকার হলে counting semaphore বা queue. FreeRTOS-এ mutex ব্যবহারে configUSE_MUTEXES 1 রাখতে হয়। Task-এর মধ্যে data পাঠানোর ভালো পথ, queue, পর্ব ৫৮-এ।
আরও গভীরে: ১৯৮০ সালে Butler Lampson আর David Redell Xerox-এর Mesa ভাষার monitor নিয়ে অভিজ্ঞতার একটি প্রবন্ধে তিন priority-র এই সমস্যা আর তার একটি প্রতিকার (তালা-ধারীর priority অপেক্ষমাণদের সর্বোচ্চে তোলা) বর্ণনা করেন; এটি পরিচিত প্রথম দিকের বর্ণনাগুলোর একটি, যদিও কে প্রথম, তা নিশ্চিত করা কঠিন। Linux kernel-এর rt_mutex আর POSIX-এর PTHREAD_PRIO_INHERIT একই inheritance ধারণার বাস্তবায়ন। FreeRTOS-এর mutex-এর নথি নিজেই লেখে, priority inheritance inversion সারায় না, শুধু কিছু ক্ষেত্রে প্রভাব কমায়, আর hard real-time নকশায় inversion যাতে আদৌ না ঘটে সেভাবে সাজানো উচিত। তার বাস্তবায়ন ইচ্ছা করে সরল: একটি task সব ধরা mutex ছাড়ার আগ পর্যন্ত পাওয়া সর্বোচ্চ priority-তে থাকে।
পরীক্ষা ও ইন্টারভিউতে: “Mutex আর binary semaphore-এর পার্থক্য?” → mutex-এর মালিক আছে, শুধু মালিক ছাড়ে, তাই inheritance সম্ভব; semaphore সংকেতের জন্য, ISR থেকে give করা যায়। “Priority inversion কী, উদাহরণসহ?” → নিচু task তালা ধরা, উঁচু অপেক্ষায়, মাঝারি নিচুটিকে সরিয়ে রাখে; simulator-এ 11 বনাম 5 tick. “Inheritance আর ceiling-এর পার্থক্য?” → inheritance অপেক্ষা শুরু হলে উঁচু করে, ceiling তালা ধরামাত্র; ceiling deadlock-ও ঠেকায়। “Mars Pathfinder-এ কী হয়েছিল?” → inversion-এ উঁচু task deadline হারায়, প্রহরী reset করে; inheritance চালু করে সমাধান। “দুই mutex-এ deadlock কীভাবে ঠেকাবেন?” → সবাই একই ক্রমে নেবে, বা একসাথে দুটি ধরবে না।
৯ · AI-এর যুগে RTOS-এর তালা যাচাই
AI assistant RTOS-এর কোড দ্রুত লিখে দেয়, আর synchronization-এর ভুলগুলো এমন যে পরীক্ষায় প্রায় কখনো ধরা পড়ে না। সাধারণ ভুল আর ধরার উপায়:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
| তালা হিসেবে binary semaphore দেয়, “mutex-এর মতোই” বলে | মালিকানা আর inheritance-এর প্রশ্ন; simulator-এ inv_sem-এর মতো run |
ISR-এ xSemaphoreTake বা mutex ডাকে | RTOS-এর নথিতে “FromISR” নিয়ম; ISR-এ কোনো অপেক্ষা নেই |
portMAX_DELAY দিয়ে চিরকাল অপেক্ষা, ত্রুটির পথ নেই | প্রতিটি take-এ সময়সীমা আর counter; ত্রুটির পথে তালা ছাড়া হচ্ছে কি না |
| দুটি task-এ দুটি তালা উল্টো ক্রমে নেয় | প্রতিটি তালার ক্রম লিখে মেলানো; simulator-এ deadlock scenario |
Critical section-এ printf, delay বা ধীর I/O রাখে | তালা ধরার সময় মাপা; সেটি অন্যদের B হিসেবে হিসাবে বসানো |
| অন্য RTOS-এর API নাম বা ভুল argument মিশিয়ে দেয় | RTOS-এর header (semphr.h) আর অফিশিয়াল নথি মিলিয়ে দেখা |
প্রসঙ্গ আর যাচাইয়ের শর্ত শুরুতেই দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১Mars Pathfinder-এর reset launch-এর আগের পরীক্ষাতেও দেখা গিয়েছিল, কিন্তু আবার ঘটানো যায়নি। এমন একটি bug পরীক্ষা পেরিয়ে মঙ্গলে পৌঁছাল কেন, আর ঘটনাটি থেকে এমবেডেড দলের জন্য কোন শিক্ষাগুলো আজও প্রযোজ্য?
Glenn Reeves-এর ১৯৯৭ সালের ডিসেম্বরের চিঠি অনুযায়ী, launch-এর আগে দল কয়েকবার reset দেখেছিল, কিন্তু খুঁজতে গিয়ে আবার ঘটাতে পারেনি; আর পরীক্ষার বেশিরভাগ হয়েছিল “সেরা ক্ষেত্রের” উচ্চ data হার আর বৈজ্ঞানিক কাজের পরিস্থিতিতে। এখানে দুটি কারণ একসাথে। প্রথমত, priority inversion একটি সময়-নির্ভর bug: তিনটি task-কে একটি নির্দিষ্ট ক্রমে আর নির্দিষ্ট মুহূর্তে মিলতে হয়, নিচু task তালা ধরে থাকার সেই ছোট জানালায় মাঝারি task-কে জাগতে হয়। এই পর্বের simulator-এ phase এক tick সরালেই ফল বদলায়। মাঠে, অর্থাৎ মঙ্গলে, আবহাওয়ার data সংগ্রহ আর যোগাযোগের সময়সূচি নতুন ধরনের মিল তৈরি করেছিল, যা পরীক্ষার পরিস্থিতিতে বিরল ছিল।
দ্বিতীয়ত, ঘটনাটি ধরা পড়েছিল কারণ নকশায় একটি প্রহরী ছিল: bc_sched দেখত bc_dist তার চক্র শেষ করেছে কি না। Reset বিরক্তিকর হলেও এটি নিরাপদ ব্যর্থতা: system আটকে না থেকে আবার শুরু হয়েছে। আর দল সমস্যাটি পৃথিবীতে প্রতিরূপে trace চালিয়ে আবার ঘটাতে পেরেছিল; Reeves লেখেন, এক দিনেরও কম সময়ে। Trace ক্ষমতা মহাকাশযানের software-এ রেখে দেওয়ার সিদ্ধান্ত, আর patch পাঠানোর ব্যবস্থা, এই দুটি ছাড়া সমাধান অনেক কঠিন হতো।
আজকের এমবেডেড দলের জন্য শিক্ষাগুলো সরাসরি। এক, প্রতিটি তালার জন্য লিখে রাখুন কে কে ধরে আর inheritance বা ceiling আছে কি না; Pathfinder-এ inheritance-এর সুবিধা RTOS-এ ছিল, শুধু চালু ছিল না। দুই, পরীক্ষায় সবচেয়ে খারাপ ভার আর অস্বাভাবিক সময়সূচি ইচ্ছা করে চালান, “সেরা ক্ষেত্র” নয়; simulator-এ phase বদলে বদলে run একই চিন্তার ছোট রূপ। তিন, একবার দেখা কিন্তু আবার না-ঘটা ব্যর্থতাকে “অদ্ভুত” বলে ছেড়ে দেবেন না; সেটি প্রায়ই সময়-নির্ভর bug-এর একমাত্র চিহ্ন। চার, watchdog আর deadline-পাহারা রাখুন, আর field-এ log বা trace পাওয়ার পথ রাখুন। বাজারঘরের cold room-এ একটি “lock timeout” counter আর alarm task-এর deadline পাহারা একই ধারণার ছোট সংস্করণ।
মূল উপলব্ধি: সময়-নির্ভর bug পরীক্ষায় লুকায়, মাঠে বেরোয়। তাই নকশার স্তরে নিশ্চয়তা (inheritance, তালার ক্রম, সীমিত critical section) আর মাঠে ধরার ব্যবস্থা (watchdog, trace, counter) দুটিই দরকার।
প্র ০২Priority inheritance থাকলে H-এর response 11 থেকে 5 হলো, কিন্তু M-এর 6 থেকে 9. এটি কি M-এর প্রতি অন্যায়? Inheritance আর ceiling-এর মধ্যে বাছাইয়ে আর কী কী বিবেচনা আসে?
অন্যায় নয়, বরং ঠিক এটাই চাওয়া। Fixed-priority নকশায় priority মানে “কোন কাজ আগে শেষ হওয়া বেশি জরুরি”। Inheritance ছাড়া M আসলে H-এর আগে শেষ হচ্ছিল, যা priority-র ক্রমের উল্টো। Inheritance সেই ক্রম ফিরিয়ে দেয়: H আগে, M পরে। M-এর বাড়তি 3 tick হলো push-through blocking, অর্থাৎ L-এর critical section-এর বাকি অংশ, যা H-এর হয়ে চলেছে। গুরুত্বপূর্ণ কথা, এটি সীমিত আর হিসাবযোগ্য: response-time analysis-এ M-এর B-তে এটি ধরা যায়, আর এই পর্বের cold room-এর হিসাবে CTL-এর সীমা 7, simulator-এ দেখা 6. সীমাহীন inversion-এর সঙ্গে এর পার্থক্য এখানেই।
Inheritance বনাম ceiling বাছাইয়ে কয়েকটি বিবেচনা আসে। এক, deadlock: ceiling-এর মূল protocol (Sha, Rajkumar, Lehoczky, ১৯৯০) তালার চক্র অসম্ভব করে, inheritance করে না; এই পর্বের deadlock_pi.json-এ inheritance থাকা সত্ত্বেও deadlock হয়েছে। দুই, blocking-এর সংখ্যা: ceiling-এ একটি task সর্বোচ্চ একটি নিচু critical section-এর জন্য আটকায়; inheritance-এ শিকলের মতো কয়েকটির জন্য আটকাতে পারে (অংশ ৫-এর chain). তিন, ceiling-এর দাম: প্রতিটি তালার ceiling আগে থেকে জানতে হয়, অর্থাৎ কোন task কোন তালা নেয় তার পূর্ণ তালিকা। নতুন task যোগ হলে ceiling বদলাতে হয়, ভুল হলে নিরাপত্তা ভাঙে। চার, immediate ceiling-এ তালা ধরামাত্র priority বাড়ে, তাই উঁচু task না এলেও মাঝারি task-রা অপেক্ষা করে; গড় response একটু খারাপ হতে পারে। পাঁচ, প্রাপ্যতা: অনেক ছোট RTOS-এ mutex-এ inheritance তৈরি অবস্থায় থাকে (FreeRTOS-এর mutex যেমন), ceiling সবখানে থাকে না।
বাস্তবে তাই ছোট MCU firmware-এ সাধারণ পথ হলো inheritance-সহ mutex, অল্প তালা, আর তালার কঠোর ক্রম। নিরাপত্তা-সংবেদনশীল ব্যবস্থায়, যেখানে প্রমাণ দরকার আর task-এর তালিকা স্থির, ceiling বেশি আকর্ষণীয়, কারণ তার সীমা প্রমাণ সহজ।
মূল উপলব্ধি: Inheritance-এ মাঝারি task-এর দেরি অন্যায় নয়, priority-র ক্রমের পুনরুদ্ধার; বাছাইয়ের আসল প্রশ্ন হলো deadlock-এর ঝুঁকি, blocking-এর সংখ্যা আর ceiling-এর তালিকা রক্ষণাবেক্ষণের খরচ।
প্র ০৩একক-core MCU-তে interrupt বন্ধ রাখাও তো একটি তালা, আর তাতে কোনো priority inversion বা deadlock হয় না। তাহলে RTOS-এ সব critical section এভাবেই করা হয় না কেন?
প্রশ্নের প্রথম অংশ ঠিক। একক-core-এ interrupt বন্ধ (Cortex-M-এ __disable_irq(), পর্ব ৪৩) থাকলে কোনো ISR বা task switch ঘটতে পারে না, তাই যে কোড চলছে সে একা। কোনো অপেক্ষার সারি নেই, তাই deadlock-ও নেই, আর কোনো মাঝারি task ঢুকতে পারে না বলে inversion-ও নেই। আসলে এটি একটি চরম ceiling: তালা ধরামাত্র সবচেয়ে উঁচু priority. RTOS-গুলো নিজেও তাদের ভেতরের ছোট critical section (ready list বদলানো) এভাবেই রক্ষা করে।
কিন্তু দাম সবার ঘাড়ে পড়ে। Interrupt বন্ধ থাকার সময়টুকু প্রতিটি interrupt-এর latency-তে যোগ হয়, এমনকি যারা ওই সম্পদ ছোঁয়ই না। একটি I2C লেনদেন আসল chip-এ কয়েকশো মাইক্রোসেকেন্ড নিতে পারে, UART-এ একটি লাইন 115200 baud-এ মিলিসেকেন্ড (পর্ব ৫৪-এ হিসাব). এতক্ষণ interrupt বন্ধ রাখলে UART-এর পরের byte হারাতে পারে, motor-এর PWM আপডেট দেরি হতে পারে, আর সবার response-time analysis-এ একটি বড় B ঢোকে। Mutex-এ blocking শুধু তাদের হয়, যারা আসলে সম্পদটি চায়।
দ্বিতীয় সমস্যা, interrupt বন্ধ থাকলে অপেক্ষা করা যায় না: I2C লেনদেনের মাঝে peripheral-এর জন্য ঘুমানো বা DMA-র শেষ হওয়ার অপেক্ষা অসম্ভব। তৃতীয়, multicore MCU-তে (যেমন RP2040, যার দুটি core আছে) এক core-এর interrupt বন্ধ করলে অন্য core থামে না; সেখানে hardware spinlock বা অন্য ব্যবস্থা লাগে। FreeRTOS-এর Cortex-M port আসলে সব interrupt বন্ধ করে না, BASEPRI দিয়ে একটি সীমার নিচের interrupt-গুলো আটকায়, যাতে খুব জরুরি interrupt তখনো চলে; সেই সূক্ষ্মতা পর্ব ৩০-এর NVIC priority-র সঙ্গে জড়িত।
তাই নিয়মটি মাপ দিয়ে ঠিক হয়: কয়েকটি নির্দেশের critical section (একটি counter বাড়ানো, দুটি variable একসাথে পড়া) interrupt বন্ধ রেখে বা atomic নির্দেশে; লম্বা বা অপেক্ষা-সহ কাজ mutex দিয়ে।
মূল উপলব্ধি: Interrupt বন্ধ রাখা সবচেয়ে সরল আর সবচেয়ে কঠোর তালা; ছোট কাজে আদর্শ, লম্বা কাজে সবার latency নষ্ট করে। Mutex-এর জটিলতা হলো blocking-কে শুধু আগ্রহী task-দের মধ্যে সীমিত রাখার দাম।
প্র ০৪Binary semaphore দিয়ে ISR থেকে task-কে জাগানো জনপ্রিয় নকশা, অথচ অংশ ২-এর run-এ দুটি সংকেত হারিয়ে গেল। কোন পরিস্থিতিতে এই হারানো নিরাপদ, কোথায় বিপজ্জনক, আর বিকল্প কী?
Binary semaphore-এর অর্থ “অন্তত একবার ঘটেছে, এখনো সামলানো হয়নি”। ঘটনার সংখ্যা নয়, ঘটনার উপস্থিতি জানায়। তাই হারানো নিরাপদ, যখন task জেগে উঠে পুরো অবস্থা নতুন করে পড়ে নেয়, প্রতিটি ঘটনার আলাদা ছাপ দরকার হয় না। উদাহরণ: cold room-এর sensor-এর ALERT pin. দুটি ALERT পরপর এলে task একবার জেগে তাপমাত্রা পড়লেই সব জানা হয়ে যায়; দ্বিতীয় সংকেতের কোনো আলাদা তথ্য নেই। একই কথা “নতুন data আছে, buffer পড়া হোক” ধরনের সংকেতে, যদি task জেগে buffer-এর সব data পড়ে নেয়।
বিপজ্জনক, যখন প্রতিটি ঘটনার নিজস্ব তথ্য বা গণনা আছে। Smart scale-এ ধরুন একটি rotary encoder-এর প্রতিটি ধাপ একটি interrupt দেয় আর task ধাপ গুনে দাম বদলায়; সংকেত হারালে দাম ভুল। বা UART-এর প্রতিটি byte-এ একটি give: task দেরিতে জাগলে byte হারাবে। আরও সূক্ষ্ম বিপদ আছে: task যদি প্রতিবার জেগে মাত্র একটি জিনিস সামলায়, আর বাকি data buffer-এ পড়ে থাকে, তাহলে পরের সংকেত না আসা পর্যন্ত সেই data অপেক্ষা করবে, হয়তো চিরকাল। অংশ ২-এর run-এ LOG ঠিক এভাবে tick 3 থেকে চিরকাল blocked.
বিকল্প তিনটি। এক, counting semaphore: প্রতিটি give গোনা থাকে, সর্বোচ্চ সীমা পর্যন্ত; run-এ তিনটি ঘটনাই পৌঁছেছে। তবে সীমা ছাড়ালে আবার হারায়, তাই সীমা হিসাব করে বাছতে হয়। দুই, queue: ঘটনার সঙ্গে তার data-ও যায় (encoder-এর দিক, byte-এর মান), পর্ব ৫৮-এর বিষয়। তিন, binary semaphore রেখে task-এর নকশা বদলানো: জেগে উঠে buffer খালি না হওয়া পর্যন্ত loop-এ পড়া। FreeRTOS-এ task notification নামে হালকা একটি ব্যবস্থাও আছে, যা binary বা counting দুইভাবেই ব্যবহার করা যায়; তার খুঁটিনাটি পর্ব ৫৮-এ।
নকশার প্রশ্নটি তাই: সবচেয়ে খারাপ অবস্থায় task জাগার আগে কয়টি ঘটনা আসতে পারে? ISR-এর সর্বোচ্চ হার আর task-এর response time থেকে সংখ্যাটি হিসাব করা যায়, আর সেটি 1-এর বেশি হলে binary semaphore-এর ওপর ভরসা করা যায় শুধু তখনই, যখন task নিজে পুরো অবস্থা পড়ে নেয়।
মূল উপলব্ধি: Binary semaphore উপস্থিতি জানায়, গণনা নয়। ঘটনার সংখ্যা বা data গুরুত্বপূর্ণ হলে counting semaphore বা queue, আর task-এর নকশায় “জেগে সব পড়ে নেওয়া” নিয়ম।
প্র ০৫অংশ ৫-এর হিসাবে ALM-এর সীমা 4 tick, simulator-এ দেখা 3. সূত্র আর simulator না মিললে কোনটিকে বিশ্বাস করবেন? আর একটি simulator-এর run কী প্রমাণ করে, কী করে না?
দুটি ভিন্ন প্রশ্নের উত্তর দেয়, তাই দুটিই দরকার। Response-time analysis-এর সূত্র একটি ওপরের সীমা: এটি প্রমাণ করে, ধরে নেওয়া মডেলে (নির্দিষ্ট C, T, তালার দৈর্ঘ্য, inheritance) কোনো phase-এই R এর বেশি হবে না। Simulator একটি নির্দিষ্ট phase-এর ঠিক কী ঘটে তা দেখায়। এই পর্বের run-এ TEL tick 0-এ তালা ধরে এক tick চালানোর পর ALM এসেছে, তাই ALM-এর blocking 1 tick, সূত্রের 2 নয়। পূর্ণ tick-এর মডেলে (Spec decision 32-33) ALM-কে ঠিক তালা নেওয়ার মুহূর্তে আনা যায় না, কারণ একই tick-এ এলে ALM উঁচু priority নিয়ে আগে চলত। আসল chip-এ সময় অবিচ্ছিন্ন, তাই সেখানে সবচেয়ে খারাপ phase সত্যিই ঘটতে পারে, আর সূত্রের 4 ঠিক সেটিকেই ঢাকে।
অতএব, সীমা আর মাপের মধ্যে ফাঁক থাকলে সাধারণত সমস্যা নেই, যদি মাপ সীমার নিচে থাকে; সীমা নিরাপত্তার জন্য, মাপ বোঝার জন্য। মাপ সীমা ছাড়ালে বুঝতে হবে মডেলে কিছু বাদ পড়েছে: একটি অজানা তালা, ISR-এর সময়, context switch-এর খরচ, বা ভুল C. Simulator-এর run তখন bug ধরার যন্ত্র।
একটি run কী প্রমাণ করে না: অন্য phase, অন্য release-এর ক্রম, অন্য execution time. পর্ব ৫৪-এ দেখেছেন, মাপা সর্বোচ্চ কেবল নিচের সীমা। Simulator-এর ক্ষেত্রেও একই কথা: একটি scenario একটি সম্ভাবনা। আরও আস্থার জন্য অনেক phase-এ চালানো যায় (offset বদলে বদলে), যা ছোট task-সেটে সব সম্ভাবনা ঢাকতে পারে; বড় system-এ এর জায়গা নেয় model checking-এর মতো আনুষ্ঠানিক পদ্ধতি। আর মনে রাখুন, simulator-এর নিজস্ব সরলীকরণ আছে: শূন্য সময়ের lock আর unlock, পূর্ণ tick, context switch-এর খরচ শূন্য। আসল RTOS-এ এদের প্রতিটি সময় নেয়, যা C-তে যোগ করতে হয়।
সবশেষে, দুটির মিল নিজেই একটি পরীক্ষা: TEL-এর সীমা 9 আর মাপ 9 হুবহু মিলেছে, যা দেখায় C আর T ঠিকভাবে বসানো হয়েছে। একটি সীমা যদি কখনোই মাপের কাছে না আসে, সেটিও প্রশ্ন তোলে: হয়তো মডেলটি অযথা হতাশাজনক, আর CPU-র ক্ষমতা নষ্ট হচ্ছে।
মূল উপলব্ধি: সূত্র সব phase-এর জন্য সীমা দেয়, simulator একটি phase-এর সত্য। নিরাপত্তার দাবি সীমা থেকে, বোঝা আর bug ধরা মাপ থেকে; মাপ সীমা ছাড়ালে মডেল ভুল।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর কোর্সের RTOS simulator বা Python-এ চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — নিরাপদ
log_line(): বাজারঘরের firmware-এ কয়েকটি task একই UART-এ লাইন লেখে। FreeRTOS-এর API দিয়ে একটিbool log_line(const char *s)লিখুন, যা (ক) পুরো লাইনকে অবিভাজ্য রাখে, (খ) priority inversion সীমিত রাখে, (গ) 50 ms-এর মধ্যে তালা না পেলেfalseফেরায় আর একটি counter বাড়ায়, (ঘ) ISR থেকে ডাকা হলে কী করবেন, তা বলুন।/* উদাহরণ, চালানো হয়নি — FreeRTOS-এর API */ static SemaphoreHandle_t uart_mtx; /* init-এ xSemaphoreCreateMutex() */ static volatile uint32_t log_drops; bool log_line(const char *s) { if (xSemaphoreTake(uart_mtx, pdMS_TO_TICKS(50)) != pdTRUE) { log_drops++; /* তালা পাইনি: লাইন বাদ */ return false; } uart_puts(s); /* critical section: শুধু লেখা */ xSemaphoreGive(uart_mtx); /* প্রতিটি পথে ছাড়া */ return true; }(ক) পুরো লাইন একটি take-give জোড়ার মধ্যে, তাই অংশ ১-এর মতো মিশে যাওয়া অসম্ভব। (খ) Binary semaphore নয়, mutex: FreeRTOS-এর mutex-এ priority inheritance আছে, তাই নিচু task লাইন লেখার সময় উঁচু task অপেক্ষা করলে মাঝারি task ঢুকতে পারে না। তবু উঁচু task-এর B হলো সবচেয়ে লম্বা লাইন লেখার সময়; polled UART-এ 115200 baud-এ প্রতি অক্ষর প্রায় 86.8 µs (পর্ব ৪৯), তাই লাইন ছোট রাখা বা ring buffer-এ কপি করে তালা দ্রুত ছাড়া ভালো নকশা। (গ) সময়সীমা আর counter: deadlock বা আটকে থাকা task থাকলে firmware চিরকাল থামে না, আর counter দেখে মাঠে সমস্যা ধরা যায়। কোনো return পথে তালা ধরা থেকে যায় না। (ঘ) ISR থেকে mutex নেওয়া যায় না, আর ISR অপেক্ষা করতে পারে না; তাই ISR লাইনটি একটি queue-তে পাঠাবে (FromISR API দিয়ে), আর একটি logger task সেটি
log_line()দিয়ে লিখবে (পর্ব ৫৮). -
ভুল খুঁজুন — তিনটি synchronization-এর ভুল: একজন লিখেছেন:
ধরুনSemaphoreHandle_t bus = xSemaphoreCreateBinary(); xSemaphoreGive(bus); void EXTI0_IRQHandler(void) { xSemaphoreTake(bus, 0); read_i2c(); xSemaphoreGive(bus); } void tel_task(void *p) { for (;;) { xSemaphoreTake(bus, portMAX_DELAY); if (!sensor_ok()) return_error(); /* এখান থেকে লুপের শুরুতে ফেরে */ xSemaphoreTake(uart, portMAX_DELAY); send(); xSemaphoreGive(uart); xSemaphoreGive(bus); } }return_error()একটি ত্রুটি গুনেcontinue-এর মতো লুপের শুরুতে ফেরে, আর অন্য একটি task আগেuartতারপরbusনেয়। ভুলগুলো দেখান।ভুল ১, তালা হিসেবে binary semaphore:
busএকটি binary semaphore, তাই priority inheritance নেই (FreeRTOS-এর নথি অনুযায়ী binary semaphore inheritance ব্যবহার করে না); simulator-এরinv_sem.json-এ ঠিক এই কারণে H-এর response 11. মালিকও নেই, যে কেউ ভুল করে give করলে দুজন একসাথে ঢুকে যায়। তালা হলেxSemaphoreCreateMutex().ভুল ২, ISR-এ তালা: ISR-এ সাধারণ
xSemaphoreTakeডাকা চলে না, আর mutex ISR-এ চলেই না। তার ওপরxSemaphoreTake(bus, 0)-এর ফল দেখা হয়নি: তালা না পেলেও ISR I2C পড়ছে, ঠিক যখন task-টি bus ব্যবহার করছে। সমাধান: ISR শুধু একটি semaphore বা queue-তে সংকেত দেবে (FromISR), I2C পড়বে task.ভুল ৩, ত্রুটির পথে তালা ধরা থেকে যায়:
sensor_ok()ব্যর্থ হলে লুপ শুরুতে ফেরে,busছাড়া হয়নি। পরের চক্রেportMAX_DELAY-এ task নিজের ধরা তালার জন্য চিরকাল অপেক্ষা করে। প্রতিটি পথে give, আর সময়সীমা।ভুল ৪ (বোনাস), উল্টো ক্রম: এই task
busতারপরuart, অন্য taskuartতারপরbus: অংশ ৭-এর মতো deadlock-এর চক্র (simulator:DEADLOCK: SEN -> TEL -> SEN). একটি স্থায়ী ক্রম, বাbusছেড়ে তবেuart. -
আগে বলুন — inversion-এর আরেকটি phase: Preemptive fixed-priority, এক tick-এ এক task, বড় সংখ্যা বেশি জরুরি। L (priority 1, tick 0-এ আসে): S ধরে, 3 tick কাজ, S ছাড়ে, 1 tick কাজ। H (priority 3, tick 1-এ আসে): S ধরে, 1 tick কাজ, S ছাড়ে। M (priority 2, tick 2-এ আসে): 5 tick কাজ, কোনো তালা নেই। (ক) Inheritance ছাড়া H কখন শেষ হবে, response কত? (খ) Inheritance-সহ? (গ) দুই ক্ষেত্রে M-এর response?
(ক) L tick 0 চলে। Tick 1-এ H আসে, S চায়, blocked; L tick 1 চলে। Tick 2-এ M আসে, L-কে সরিয়ে tick 2 থেকে 6 চলে, শেষ 7-এ। L tick 7-এ তার শেষ critical section-এর tick চালায়; tick 8-এর শুরুতে S ছাড়ে, H S পায়, tick 8 চলে, শেষ 9-এ: response 8. (খ) Tick 1-এ H blocked হতেই L priority 3 পায়; tick 2-এ M এসে ready থাকে। L tick 1 আর 2 চলে, tick 3-এর শুরুতে S ছাড়ে, H tick 3 চলে, শেষ 4-এ: response 3. (গ) Inheritance ছাড়া M-এর response 5 (2 থেকে 7), inheritance-সহ M চলে tick 4 থেকে 8, শেষ 9-এ: response 7. দুটিই reference lab-এর
rtos_sim.py run-এ মেলানো: inheritance ছাড়া Gantt-এ H.BBBBBBB#....., সঙ্গে.BB#..........; L-এর response দুই ক্ষেত্রেই 10. -
হিসাব — blocking-সহ response time: তিনটি periodic task, priority-র ক্রমে উঁচু থেকে নিচু: T1 (C = 1, T = 5, mutex S ধরে 1 tick), T2 (C = 2, T = 12, কোনো তালা নেই), T3 (C = 3, T = 20, S ধরে 2 tick). Priority inheritance আছে, deadline = period. প্রতিটি task-এর B আর R হিসাব করুন, ধাপে ধাপে।
B: T1-কে আটকাতে পারে নিচুদের S-এর critical section, সবচেয়ে লম্বা T3-এর 2: B1 = 2. T2 নিজে S ছোঁয় না, কিন্তু উঁচু T1 ছোঁয়; T3 যখন T1-এর priority ধার করে চলে, T2-ও অপেক্ষা করে (push-through): B2 = 2. T3-এর নিচে কেউ নেই: B3 = 0.
R1 = 1 + 2 = 3 ≤ 5.
R2: শুরু 2; R = 2 + 2 + ⌈2/5⌉×1 = 5; আবার: 2 + 2 + ⌈5/5⌉×1 = 5, স্থির। 5 ≤ 12.
R3: শুরু 3; R = 3 + 0 + ⌈3/5⌉×1 + ⌈3/12⌉×2 = 6; তারপর 3 + ⌈6/5⌉×1 + ⌈6/12⌉×2 = 3 + 2 + 2 = 7; তারপর 3 + ⌈7/5⌉×1 + ⌈7/12⌉×2 = 7, স্থির। 7 ≤ 20.
অংশ ৫-এর
rta_blocking.py-এর একই নিয়মে Python-এ চালিয়ে মেলানো: T1[1, 3, 3], T2[2, 5, 5], T3[3, 6, 7, 7]. সব deadline রক্ষা। Inheritance না থাকলে B1-এ T2-এর কাজও ঢুকত, আর আরও মাঝারি task থাকলে তার কোনো সীমা থাকত না।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমInheritance ছাড়া একটি RTOS-এ সীমাহীন priority inversion-এর ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- নিচু priority-র task একটি mutex ধরে critical section-এ ঢোকে
- উঁচু priority-র task এসে নিচুটিকে preempt করে
- উঁচু task একই mutex চায় আর blocked হয়
- নিচু task আবার চলতে শুরু করে
- মাঝারি priority-র task এসে নিচুটিকে সরিয়ে দীর্ঘক্ষণ চলে
- নিচু task অবশেষে mutex ছাড়ে, উঁচু task তা পেয়ে চলে
একটি RTOS-এ L (priority 1) একটি mutex ধরে আছে, H (priority 3) সেই mutex-এর অপেক্ষায় blocked, আর M (priority 2) ready, কোনো তালা ছোঁয় না। Mutex-এ priority inheritance চালু থাকলে এই মুহূর্তে কোন task চলবে?
- M, কারণ ready task-দের মধ্যে তার priority সবচেয়ে বেশি
- L, কারণ সে সাময়িকভাবে H-এর priority পায়
- H, কারণ তার priority সবচেয়ে বেশি
- কেউ না, এটি deadlock
Mutex আর binary semaphore-এর মূল পার্থক্য কোনটি?
- Mutex-এর মান 0 থেকে 255 পর্যন্ত হতে পারে
- শুধু mutex ISR থেকে ছাড়া যায়
- Mutex-এর মালিক আছে আর শুধু মালিক ছাড়তে পারে, তাই priority inheritance সম্ভব
- Semaphore-এ অপেক্ষারত task লুপে ঘোরে, mutex-এ ঘুমায়
একটি ISR খুব দ্রুত পরপর তিনবার একটি binary semaphore give করে, যার মান শুরুতে 0, আর অপেক্ষারত task তখনো জাগেনি (ISR-এর priority বেশি)। Task পরে কয়বার take করে সফল হবে, নতুন কোনো give ছাড়া?
- একবারও না
- তিনবার
- দুবার
- একবার
দুটি task: A আগে mutex X তারপর Y নেয়, B আগে Y তারপর X নেয়, দুজনেই প্রথমটি ধরে রেখে দ্বিতীয়টি চায়। দুটি mutex-এই priority inheritance চালু। নিচের কোনটি deadlock নিশ্চিতভাবে ঠেকায়?
- দুজনেই আগে X তারপর Y নেবে
- Priority inheritance আরও উঁচু করে দেওয়া
- A-কে B-এর চেয়ে বেশি priority দেওয়া
- Mutex-এর বদলে binary semaphore ব্যবহার করা
Priority inheritance-সহ একটি fixed-priority system-এ task i-এর C = 2, উঁচু একটি task-এর C = 1 আর T = 5, আর নিচু task-দের যে critical section i-কে আটকাতে পারে তার সবচেয়ে লম্বাটি 2. Response-time analysis-এ Ri কত (deadline 10)?
- 3
- 5
- 6
- 7
১৯৯৭ সালে Mars Pathfinder-এর বারবার reset-এর প্রকাশিত ব্যাখ্যা অনুযায়ী মূল কারণ আর সমাধান কী ছিল?
- Stack overflow; সমাধান stack বড় করা
- দুই task-এর deadlock; সমাধান তালার ক্রম বদলানো
- Priority inversion; সমাধান mutex-এ priority inheritance চালু করা
- Watchdog-এর ভুল; সমাধান watchdog বন্ধ করা
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- ভাগ করা সম্পদ = তালা: প্রতিটি সম্পদের জন্য কে ছোঁয়, কোন তালা, কতক্ষণ ধরা; শেষ সংখ্যাটি অন্যদের blocking time.
- Semaphore সংকেত আর গোনার জন্য: binary উপস্থিতি জানায় (বাড়তি give হারায়), counting গোনে; ISR থেকে শুধু FromISR give.
- Mutex তালার জন্য: মালিক আছে, শুধু মালিক ছাড়ে, তাই priority inheritance সম্ভব; ISR-এ নয়।
- Priority inversion: মাঝারি task নিচুটিকে সরিয়ে উঁচুটিকে অনির্দিষ্টকাল আটকায় (simulator-এ 11 tick); inheritance বা ceiling দিলে সীমিত (5 tick), আর R = C + B + উঁচুদের বাধা।
- Deadlock: উল্টো ক্রমে দুটি তালা চক্র বানায়, inheritance সারায় না; একই ক্রম, একসাথে না ধরা, আর সময়সীমা।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ৪৩ · Interrupt আর ISR নকশাআগের ভিত্তিISR আর main loop-এর shared data, interrupt বন্ধ রেখে critical section.
- পর্ব ৫৪ · Real-time systemআগের ভিত্তিDeadline, WCET আর response time, যার ওপর blocking-এর হিসাব দাঁড়ায়।
- Operating Systems পর্ব ২৪ · Mutex আর semaphoreপাশের ট্র্যাকFutex, POSIX API আর semaphore-এর তত্ত্ব, OS-এর দিক থেকে।
- Operating Systems পর্ব ২৭ · Deadlockপাশের ট্র্যাকচার শর্ত, ঠেকানো, এড়ানো আর ধরা।