এই পর্বে যা শিখবেন
- Task, TCB আর task-এর চার অবস্থা চেনা, আর কোন ঘটনায় task এক অবস্থা থেকে আরেক অবস্থায় যায় বলতে পারা
- Cortex-M-এ context switch-এর প্রতিটি ধাপ: কোন register hardware রাখে, কোনটি RTOS, আর PendSV কেন সবচেয়ে কম জরুরি
- Preemptive fixed priority, round-robin আর cooperative scheduling-এর পার্থক্য simulator-এর run দিয়ে দেখা
- Rate-monotonic নিয়মে priority দেওয়া, Liu–Layland সীমা দিয়ে দ্রুত পরীক্ষা, আর response-time analysis হাতে করা
- Task-প্রতি stack-এর হিসাব করা আর বাস্তব RTOS-এর API-তে নকশাটি লেখা
১ · Super loop থেকে task — RTOS কী সমস্যা মেটায়
পর্ব ৫৪-এ দেখেছেন real-time-এর ভাষা: deadline, WCET, period আর utilisation. পর্ব ৫৫-এ দেখেছেন RTOS ছাড়া firmware কীভাবে চলে: একটি super loop, যেখানে প্রতিটি কাজ নিজের পালা শেষ করে পরেরজনকে সুযোগ দেয়। সেখানে সমস্যা একটিই: একটি লম্বা কাজ চলার সময় জরুরি কাজটিও অপেক্ষা করে। এই পর্বে সেই সমস্যার সমাধান, একটি RTOS-এর scheduler, যে জরুরি কাজের জন্য লম্বা কাজকে মাঝপথে থামাতে পারে। এই পর্বে hex লেখা হবে C-ধাঁচে, 0x….
উপমা — বাজারঘরের একজন কর্মচারী, তিনটি দায়িত্ব: তাঁকে প্রতি কয়েক মিনিটে cold room-এর থার্মোমিটার দেখতে হয় (ছোট কাজ, কিন্তু দেরি চলবে না), মাঝে মাঝে কাউন্টারের বোর্ডে দাম লিখতে হয়, আর দিনে কয়েকবার মালিককে লম্বা হিসাব পাঠাতে হয়। Super loop-এর কর্মচারী হিসাব লিখতে বসলে শেষ না করে ওঠেন না, তাই থার্মোমিটার দেখা পিছিয়ে যায়। RTOS-এর কর্মচারীর হাতে একটি অ্যালার্ম ঘড়ি: থার্মোমিটারের সময় হলেই তিনি হিসাবের খাতায় একটি দাগ দিয়ে রাখেন (কোথায় থেমেছিলেন), থার্মোমিটার দেখে আসেন, তারপর ঠিক সেই দাগ থেকে আবার লেখেন। দাগ দিয়ে রাখার কাজটিই context switch, আর কোন কাজ আগে, তা ঠিক করা scheduling.
এই পর্ব জুড়ে চলবে বাজারঘরের cold-storage monitor-এর তিনটি task. README-র নকশায় তাপমাত্রা পড়া হয় প্রতি 1 s-এ, আর telemetry যায় প্রতি 10 s-এ; মাঝে একটি display বা UART-এর কাজ:
| Task | কাজ | আসল নকশায় | এই পর্বের মডেলে (C, T tick-এ) |
|---|---|---|---|
SENS | I2C-তে তাপমাত্রা পড়া, ৩ reading-এর নিয়মে alarm যাচাই | প্রতি 1 s | C = 1, T = 4 |
UI | UART-এ লাইন ছাপা, alarm-এর LED (PA6) | নিয়মিত, মাঝারি | C = 2, T = 6 |
TELE | Telemetry-র JSON বানানো আর পাঠানো | প্রতি 10 s | C = 3, T = 12 |
মডেলের সংখ্যাগুলো ছোট রাখা হয়েছে, যাতে পুরো schedule এক নজরে দেখা যায়; ক্রমটি আসলের মতো (SENS সবচেয়ে ঘন, TELE সবচেয়ে বিরল). সব schedule এসেছে কোর্সের reference lab-এর rtos_sim.py থেকে: একটি নির্ধারিত (deterministic) simulator, যেখানে সময় চলে পূর্ণ tick-এ, প্রতি tick-এ একটি task বা idle চলে, আর বড় priority সংখ্যা মানে বেশি জরুরি, FreeRTOS-এর মতো (Spec decision 32). সতর্ক থাকুন: Cortex-M-এর NVIC-এ উল্টো, সেখানে কম সংখ্যা জরুরি (পর্ব ৩০).
Lab-এর সীমা: কোর্সের virtual বাজারঘর board (BG-M3) PendSV, SVC আর PSP মডেল করে না (Spec decision 19), তাই কোনো আসল RTOS board-এ চালানো যায় না। এই পর্বের schedule-গুলো তাই simulator-এর, context switch-এর ধাপগুলো ARM-এর নিয়ম আর FreeRTOS-এর উৎস-কোড থেকে, আর FreeRTOS-এর কোড “উদাহরণ, চালানো হয়নি”.
২ · Task, TCB আর task-এর চার অবস্থা
RTOS-এর task দেখতে একটি সাধারণ C function, যা কখনো ফেরে না: ভেতরে একটি অসীম loop, যার প্রতিটি পাক শেষে task নিজে অপেক্ষায় যায় (“পরের 1 s পর্যন্ত ঘুমানো”). দুটি জিনিস task-কে function থেকে আলাদা করে। এক, প্রতিটি task-এর নিজের stack, কারণ থেমে থাকা task-এর local variable, ফেরার ঠিকানা আর register সেখানেই জমা থাকে। দুই, RTOS প্রতিটি task-এর একটি খাতা রাখে, যার নাম task control block (TCB).
| TCB-এর ঘর | কী রাখে | কেন |
|---|---|---|
| saved stack pointer | থামার মুহূর্তে task-এর stack-এর মাথা | ফেরার সময় এখান থেকেই সব register তোলা হয়; FreeRTOS-এ এটি TCB-এর একেবারে প্রথম ঘর |
| priority | নিজস্ব (base) priority | Scheduler-এর বাছাই; পর্ব ৫৭-এ inheritance এটি সাময়িক বাড়াবে |
| state ও list-এর সংযোগ | কোন তালিকায় আছে: ready, delay, কোনো অপেক্ষা | অবস্থা বদলানো মানে এক তালিকা থেকে আরেক তালিকায় সরানো |
| stack-এর শুরু ও আকার | Stack-এর সীমা | Overflow ধরা আর high-water mark মাপা |
| wake time, নাম | কখন জাগবে; debug-এর নাম | Delay আর debugger-এর তালিকা |
প্রতিটি task সবসময় চারটি অবস্থার একটিতে থাকে; FreeRTOS-এর eTaskState-এও এই নামগুলোই আছে (eRunning, eReady, eBlocked, eSuspended, সাথে মুছে ফেলা task-এর eDeleted):
ছবি ৫৬.১ — Task-এর চার অবস্থা আর কোন ঘটনায় বদলায়
একক core-এ এক মুহূর্তে শুধু একটি task running; বাকি সব ready, blocked বা suspended
eTaskGetState suspended বলে জানায়।Blocked আর suspended-এর পার্থক্য পরীক্ষায় প্রায়ই আসে। Blocked task একটি নির্দিষ্ট ঘটনার অপেক্ষায় (সময়, queue-তে data, semaphore), আর ঘটনা এলে নিজে থেকেই ready হয়। Suspended task কোনো কিছুর অপেক্ষায় নেই; অন্য কেউ স্পষ্টভাবে resume না করা পর্যন্ত scheduler তাকে দেখেই না। Ready task-রা থাকে ready list-এ, প্রতিটি priority-র জন্য আলাদা তালিকা। কেউ ready না থাকলে চলে idle task, সবচেয়ে কম priority-র (FreeRTOS-এ 0) একটি task, যা সাধারণত CPU-কে ঘুম পাড়ায় (পর্ব ৬০-এ low-power).
একটি বাস্তব RTOS-এ task বানানো এভাবে দেখায়। নিচের কোডটি FreeRTOS-এর API-তে লেখা উদাহরণ, চালানো হয়নি; নামগুলো FreeRTOS Kernel-এর task.h থেকে মেলানো (FreeRTOS MIT লাইসেন্সে বিতরণ হয়):
#include "FreeRTOS.h"
#include "task.h"
static void sens_task(void *arg) /* RM: সবচেয়ে ছোট period */
{
(void)arg;
TickType_t last = xTaskGetTickCount();
for (;;) {
read_temp_and_check_alarm(); /* I2C + ৩ reading-এর নিয়ম */
xTaskDelayUntil(&last, pdMS_TO_TICKS(1000)); /* পরম সময়ে */
}
}
int main(void)
{
board_init();
/* stack-এর আকার word-এ (byte নয়); priority: বড় সংখ্যা = জরুরি */
xTaskCreate(sens_task, "SENS", 70, NULL, 3, NULL);
xTaskCreate(ui_task, "UI", 95, NULL, 2, NULL);
xTaskCreate(tele_task, "TELE", 183, NULL, 1, NULL);
vTaskStartScheduler(); /* সফল হলে আর ফেরে না */
for (;;) { }
}এটি চালানো হয়নি, তাই কোনো আউটপুট নেই। লক্ষ্য করার তিনটি জিনিস। এক, xTaskDelayUntil পরের জাগার সময় গোনে আগের জাগার সময় থেকে, কাজ শেষের সময় থেকে নয়; পর্ব ৫৪-এর drift-এর সমাধান এটিই (পুরোনো নাম vTaskDelayUntil এখন এর ওপর একটি macro). সাধারণ vTaskDelay(n) “এখন থেকে n tick” গোনে, তাই কাজের সময়ের ওঠানামা জমে drift হয়। দুই, xTaskCreate-এর stack-এর সংখ্যা FreeRTOS-এ word-এ, Cortex-M-এ এক word = 4 byte; 70, 95 আর 183 সংখ্যাগুলো অংশ ৮-এর হিসাব থেকে। তিন, vTaskStartScheduler প্রথম task-কে চালিয়ে দেয় আর ফেরে না; ফিরলে বুঝতে হবে idle task বা timer task বানানোর memory পাওয়া যায়নি।
৩ · Context switch — কে কী রাখে, কোথায় রাখে
Context switch মানে চলমান task-এর পুরো অবস্থা জমা রেখে আরেকটির অবস্থা ফিরিয়ে আনা। সাধারণ OS-এ এর তত্ত্ব আছে Operating Systems পর্ব ০৯-এ; এখানে Cortex-M-এর যন্ত্রটি। এর ভিত্তি তিনটি জিনিস, যা আপনি আগেই দেখেছেন:
- Hardware stacking: exception-এ ঢোকার সময় CPU নিজেই আট word রাখে, R0–R3, R12, LR, ফেরার PC আর xPSR (পর্ব ৩০). অর্থাৎ অর্ধেক কাজ আগেই হয়ে আছে।
- দুটি stack pointer: task-রা চলে PSP-তে, প্রতিটি task-এর নিজের stack-এ; handler-রা সবসময় MSP-তে (পর্ব ৩৯). তাই interrupt এলে frame পড়ে চলমান task-এর stack-এ, আর handler-দের nested খরচ শুধু MSP-তে একবার।
- EXC_RETURN: handler-এর শেষে LR-এর বিশেষ মান বলে কোন stack-এ ফিরতে হবে। Thread mode আর PSP-তে ফেরার মান 0xFFFFFFFD.
বাকি অর্ধেক, r4–r11, রাখে RTOS, একটি বিশেষ exception-এ: PendSV (exception 14). SysTick-এর tick handler বা কোনো ISR যখন বোঝে যে এখন আরেকটি task-এর চলা উচিত, সে নিজে switch করে না; শুধু SCB-এর ICSR register-এ PENDSVSET বিট লিখে PendSV-কে pending করে। FreeRTOS-এর Cortex-M3 port PendSV আর SysTick-কে সবচেয়ে কম জরুরি priority দেয়, ফলে আসল switch হয় সব ISR শেষ হওয়ার পরে, একবারই, যত interrupt-ই মাঝে switch চেয়ে থাকুক। নিচের stepper-এ cold room-এর tick 4-এর মুহূর্তটি, যখন SENS জেগে TELE-কে থামায় (FreeRTOS-এর port.c অনুযায়ী ধাপ; board-এ চালানো যায় না):
| CPU কী চালাচ্ছে | |
| TELE-এর stack-এ জমা | |
| ঘটনা | |
| বর্তমান task |
- TELE চলছে। Thread mode, stack pointer PSP, যা TELE-এর নিজের stack দেখায়। SENS blocked, পরের tick-এর অপেক্ষায়; UI-ও blocked.
- SysTick এল। Hardware TELE-এর PSP-তে আট word রাখল (পর্ব ৩০-এর frame), handler mode-এ গেল, MSP ধরল, আর LR-এ বসাল 0xFFFFFFFD: “ফিরতে হবে thread mode-এ, PSP দিয়ে”.
- Tick handler সিদ্ধান্ত নিল। Tick-এর গোনা 4 হলো, SENS-এর অপেক্ষা শেষ, তাই SENS ready. SENS-এর priority 3 > TELE-এর 1, তাই switch দরকার। Handler নিজে switch না করে ICSR-এ PENDSVSET লিখল।
- PendSV ঢুকল। PendSV আর SysTick দুজনেই সবচেয়ে কম জরুরি, আর সমান priority preempt করে না; তাই PendSV অপেক্ষা করল, SysTick শেষ হতেই tail-chain করে ঢুকল। অন্য কোনো ISR চলতে থাকলে PendSV তারও পরে আসত।
- বাকি অর্ধেক জমা।
mrs r0, pspদিয়ে TELE-এর stack-এর মাথা নিয়েstmdbদিয়ে r4–r11 রাখা হলো। এখন TELE-এর stack-এ মোট ১৬ word = 64 byte (FPU ছাড়া), আর নতুন মাথাটি TELE-এর TCB-এর প্রথম ঘরে লেখা হলো। - পরের task বাছাই।
vTaskSwitchContextready-দের মধ্যে সবচেয়ে বড় priority খোঁজে। Ready বিট-এ SENS (৩), TELE (১) আর idle (০): 1011. ওপর থেকে প্রথম 1 খুঁজতে একটিclzনির্দেশই যথেষ্ট (অংশ ৫-এ Clang-এর আসল output). বর্তমান task এখন SENS. - SENS ফিরল। SENS-এর TCB থেকে তার stack-এর মাথা নিয়ে r4–r11 তোলা হলো, PSP সেখানে বসানো হলো, আর
bx lr(0xFFFFFFFD) দিয়ে ফেরা। Hardware SENS-এর stack থেকে বাকি আট word তুলল, আর SENS চলতে শুরু করল ঠিক যেখানে আগেরবার থেমেছিল।
খেয়াল করুন, switch-এর কোথাও কোনো task-এর “বিশেষ” কোড নেই: থেমে থাকা task-এর stack দেখতে ঠিক একটি interrupt-এর frame-এর মতো, আর চলা শুরু মানে সেই interrupt থেকে “ফেরা”. নতুন task-এর প্রথম চালুও একই কৌশলে হয়: RTOS তার stack-এ একটি নকল frame সাজিয়ে রাখে, যার PC-তে task-এর function-এর ঠিকানা। FreeRTOS-এর Cortex-M4F port FPU চালু থাকলে S16–S31-ও রাখে, আর hardware-এর frame-ও তখন বড় হতে পারে; তাই task-প্রতি context-এর মাপ chip আর port-এর ওপর নির্ভর করে।
৪ · তিন নীতি — preemptive, round-robin আর cooperative
সাধারণ OS-এর scheduling নীতি (FCFS, SJF, MLFQ) গড় response আর ন্যায্যতা খোঁজে; তাদের তুলনা আছে Operating Systems পর্ব ১৮-এ। RTOS-এর লক্ষ্য আলাদা: গড় নয়, সবচেয়ে খারাপ ক্ষেত্রেও deadline রাখা, আর সেটি আগে থেকে প্রমাণ করা যায় এমনভাবে। তাই প্রায় সব ছোট RTOS-এর মূল নীতি একটিই, fixed priority, আর বাকি দুটি তার রূপভেদ। rtos_sim.py-এর তিনটি scheduler ঠিক এই তিনটি (Spec decision 32):
| নীতি | কখন task বদলায় | FreeRTOS-এর config |
|---|---|---|
Preemptive fixed priority (fp) | বেশি জরুরি কেউ ready হলেই সঙ্গে সঙ্গে; সমান priority-রা পালা বদলায় না | configUSE_PREEMPTION 1, configUSE_TIME_SLICING 0 |
Fixed priority + round-robin (rr) | ওপরের নিয়ম, আর সমান priority-রা প্রতি time slice-এ পালা বদলায় | দুটিই 1 (FreeRTOS-এ slice = এক tick) |
Cooperative (coop) | শুধু যখন চলমান task নিজে block করে, yield করে বা শেষ হয় | configUSE_PREEMPTION 0 |
Round-robin — সমান priority-র ভেতরে পালা
Reference lab-এর demo rr: তিনটি সমান priority-র task A, B, C, প্রত্যেকের 3 tick কাজ, quantum 2.
সত্যিকারের run — python -B rtos_sim.py demo rr (Python 3.13.5)
scheduler: round-robin (quantum 2)
2 B A time slice ends; switch to B
4 C B time slice ends; switch to C
6 A C time slice ends; switch to A; (end of tick) A finishes (response 7)
Gantt (# running, - ready, B blocked, . not active):
0123456789
A ##----#...
B --##---#..
C ----##--#.
A released 0 start 0 finish 7 response 7
B released 0 start 2 finish 8 response 8
C released 0 start 4 finish 9 response 9
(Trace-এর মাঝের কিছু লাইন বাদ দেওয়া।) Quantum বদলালে কী হয়? নিচের ছোট মডেলটি একই তিন task quantum 1, 2 আর 3-এ চালায়; reference simulator-এ quantum 1 আর 3 চালিয়েও ঠিক এই Gantt আর response পাওয়া গেছে।
# সমান priority-র তিন task, প্রত্যেকের 3 tick কাজ, সবাই t=0-তে ready
from collections import deque
def round_robin(quantum, work=3, names="ABC"):
left = {n: work for n in names}
q = deque(names) # ready list, সামনেরটি চলে
rows = {n: "" for n in names}
finish, t, used = {}, 0, 0
while q:
run = q[0]
for n in names:
rows[n] += "#" if n == run else ("-" if n in q else ".")
left[run] -= 1
used += 1
t += 1
if left[run] == 0: # কাজ শেষ: সারি থেকে বাদ
finish[run] = t
q.popleft()
used = 0
elif used == quantum and len(q) > 1: # slice শেষ: পেছনে যায়
q.rotate(-1)
used = 0
return rows, finish
for quantum in (1, 2, 3):
rows, finish = round_robin(quantum)
avg = sum(finish.values()) / len(finish)
print(f"quantum {quantum}: response {finish}, গড় {avg:.1f}")
for n in rows:
print(f" {n} {rows[n]}")আসল আউটপুট (ব্রাউজারের Python):
quantum 1: response {'A': 7, 'B': 8, 'C': 9}, গড় 8.0
A #--#--#..
B -#--#--#.
C --#--#--#
quantum 2: response {'A': 7, 'B': 8, 'C': 9}, গড় 8.0
A ##----#..
B --##---#.
C ----##--#
quantum 3: response {'A': 3, 'B': 6, 'C': 9}, গড় 6.0
A ###......
B ---###...
C ------###
Quantum 1 বা 2-এ তিনজনই প্রায় একসাথে শেষ (7, 8, 9), গড় 8.0; quantum 3-এ প্রত্যেকে একটানা শেষ করে, তাই A 3-এ, B 6-এ, গড় 6.0. শেষজন (C) সবক্ষেত্রেই 9-এ, কারণ মোট কাজ 9 tick. শিক্ষা: round-robin ন্যায্যতা দেয়, deadline নয়; ছোট slice-এ সবাই ধীরে এগোয়, আর প্রতিটি পালা বদল একটি context switch-এর খরচ। RTOS-এ তাই round-robin শুধু সমান priority-র কয়েকটি “পটভূমির” কাজের জন্য; জরুরি কাজ আলাদা, উঁচু priority পায়।
Cooperative — কেউ নিজে না ছাড়লে কেউ পায় না
Cooperative নীতিতে scheduler কখনো চলমান task-কে থামায় না। এর সুবিধা আছে: task-রা শুধু নির্দিষ্ট জায়গায় (block বা yield-এ) বদলায়, তাই ভাগ করা data-য় হঠাৎ থামার ঝুঁকি কম, আর context switch-ও কম। অসুবিধা দেখতে TELE-এর কাজ 3 থেকে বাড়িয়ে 5 tick করা হলো (ধরুন JSON-এর সাথে একটি checksum), আর একই set চালানো হলো cooperative আর preemptive, দুইভাবে। আমার lab-এর cold_coop.json আর cold_rm5.json:
সত্যিকারের run — rtos_sim.py run cold_coop.json (scheduler: coop; অংশ)
012345678901
SENS #...----##..
UI -##...----##
TELE ---#####....
SENS released 4 start 8 finish 9 response 5 deadline 8 MISSED
deadline misses: 1
সত্যিকারের run — rtos_sim.py run cold_rm5.json --no-trace (scheduler: fp; অংশ)
012345678901
SENS #...#...#...
UI -##...##....
TELE ---#-#---###
TELE released 0 start 3 finish 12 response 12 deadline 12 met
CPU busy 12 of 12 ticks (100.0 %)
Cooperative-এ TELE tick 3 থেকে 7 পর্যন্ত একটানা চলেছে; tick 4-এ SENS ready হয়েও অপেক্ষা করেছে, আর tick 8-এ তার deadline পেরিয়েছে। Preemptive-এ ঠিক একই কাজ, একই ভার (U = 1/4 + 2/6 + 5/12 = 1.0000): কেউ deadline হারায়নি, TELE ঠিক 12-এ শেষ। পার্থক্য শুধু থামানোর অধিকারে।
Cooperative-কে বাঁচানোর উপায় লম্বা কাজকে টুকরো করে মাঝে yield. TELE-এর script 2 + 2 + 1 tick-এ ভাগ করে মাঝে দুটি yield দিলে (cold_coop_yield.json) কোনো miss নেই: tick 5-এ TELE yield করতেই SENS চলে, response 2. তবে simulator-এর trace সেখানে লেখে “SENS preempts TELE”; সেটি tool-এর শব্দ, আসলে TELE নিজে ছেড়েছে। দায়টা কোথায় সরল লক্ষ্য করুন: preemptive-এ নিশ্চয়তা দেয় scheduler, cooperative-এ প্রতিটি task-এর লেখক, যিনি প্রতিটি loop-এ মনে রাখবেন কখন ছাড়তে হবে। পর্ব ৫৫-এর super loop-এর task table এই cooperative নকশারই একটি রূপ।
৫ · Preemptive fixed priority — tick ধরে ধরে
এবার মূল নীতিটি পুরো চালিয়ে দেখা যাক। Priority দেওয়া হলো period দেখে (কেন, তা অংশ ৬-এ): SENS 3, UI 2, TELE 1. আমার lab-এর cold_rm.json-এ "priorities": "rate-monotonic", আর simulator নিজে এই সংখ্যাগুলো বসিয়েছে:
সত্যিকারের run — python -B rtos_sim.py run cold_rm.json (Python 3.13.5; job-এর তালিকার অংশ)
scheduler: preemptive fixed priority
tasks: SENS(prio 3), UI(prio 2), TELE(prio 1)
tick run events
0 SENS SENS released; UI released; TELE released; (end of tick) SENS finishes (response 1)
1 UI
2 UI (end of tick) UI finishes (response 3)
3 TELE
4 SENS SENS released; SENS preempts TELE; (end of tick) SENS finishes (response 1)
5 TELE
6 UI UI released; UI preempts TELE
7 UI (end of tick) UI finishes (response 2)
8 SENS SENS released; (end of tick) SENS finishes (response 1)
9 TELE (end of tick) TELE finishes (response 10)
10 idle
11 idle
012345678901
SENS #...#...#...
UI -##...##....
TELE ---#-#---#..
TELE released 0 start 3 finish 10 response 10 deadline 12 met
CPU busy 10 of 12 ticks (83.3 %)
Gantt-এ # মানে চলছে, - ready কিন্তু অপেক্ষায়, . কাজ নেই। Simulator-এর নিয়মে একটি job শেষ হয় তার শেষ compute tick-এর শেষে, আর response = শেষ − release (Spec decision 34). Period 12 tick পরে নকশাটি হুবহু আবার শুরু হয়, কারণ 4, 6 আর 12-এর লসাগু 12; এই দৈর্ঘ্যের নাম hyperperiod, আর একটি hyperperiod দেখাই যথেষ্ট। এবার tick ধরে ধরে:
| Tick | |
| চলছে | |
| TELE-এর বাকি কাজ | |
| SENS | |
| UI | |
| TELE |
- Tick 0: তিনজন একসাথে ready. সবচেয়ে বড় priority SENS (৩) চলে, আর tick-এর শেষে শেষ: response 1. UI আর TELE অপেক্ষায় (
-). - Tick 1–2: UI. এখন ready UI (২) আর TELE (১); UI দুই tick চলে, tick 3-এ শেষ, response 3, deadline 6-এর অনেক আগে।
- Tick 3: অবশেষে TELE. শুধু TELE ready, তাই সে শুরু করে; তিন tick-এর কাজের এক tick হলো, বাকি 2.
- Tick 4: preemption. SENS-এর দ্বিতীয় job ছাড়া হলো। SENS (৩) > TELE (১), তাই TELE মাঝপথে থামে (অংশ ৩-এর context switch), SENS চলে আর 5-এ শেষ, response আবার 1.
- Tick 5: TELE ফিরল। ঠিক যেখানে থেমেছিল সেখান থেকে; বাকি এখন 1.
- Tick 6–7: আবার থামা। UI-এর দ্বিতীয় job এল, UI (২) > TELE (১): TELE দ্বিতীয়বার থামে। UI 8-এ শেষ, response 2.
- Tick 8: SENS-এর তৃতীয় job. TELE তৃতীয়বার অপেক্ষা করে; SENS 9-এ শেষ।
- Tick 9: TELE শেষ। TELE তার শেষ tick চালায়, আর সেই tick-এর শেষে, অর্থাৎ সময় 10-এ, কাজ শেষ: response 10, deadline 12. দুবার থামলেও সময়ের ভেতরে, কারণ তার ভাগের সময় ছিল।
- Tick 10–11: idle. কেউ ready নেই; CPU 12-এর মধ্যে 10 tick ব্যস্ত, 83.3%, যা U = 0.8333-এর সাথে মেলে। Tick 12 থেকে একই নকশা আবার।
Scheduler-এর মূল কাজটি দেখতে সরল: ready-দের মধ্যে সবচেয়ে বড় priority খোঁজা। নিচের মডেলটি এই এক নিয়মেই পুরো schedule বানায়, আর পরে একই কাজ উল্টো priority-তে চালায় (অংশ ৬-এর জন্য):
# preemptive fixed priority: প্রতি tick-এ ready-দের মধ্যে সবচেয়ে বড় priority চলে
TASKS = {"SENS": (1, 4), "UI": (2, 6), "TELE": (3, 12)} # নাম: (C, T)
def simulate(prio, ticks=12):
left = {n: 0 for n in TASKS} # এই job-এর বাকি কাজ
rel = {n: 0 for n in TASKS} # এই job কখন ছাড়া হলো
rows = {n: "" for n in TASKS}
misses = []
for t in range(ticks):
for n, (c, per) in TASKS.items():
if t % per == 0: # নতুন job; আগেরটি বাকি থাকলে miss
if left[n] > 0:
misses.append(f"{n}@{rel[n]}")
left[n] += c
rel[n] = t
ready = [n for n in TASKS if left[n] > 0]
run = max(ready, key=lambda n: prio[n]) if ready else None
for n in TASKS:
rows[n] += "#" if n == run else ("-" if left[n] > 0 else ".")
if run:
left[run] -= 1
return rows, misses
for title, prio in [("RM (ছোট period = বড় priority)", {"SENS": 3, "UI": 2, "TELE": 1}),
("উল্টো ক্রম (TELE সবার ওপরে)", {"SENS": 1, "UI": 2, "TELE": 3})]:
rows, misses = simulate(prio)
print(title)
print(" 012345678901")
for n in sorted(TASKS, key=lambda n: -prio[n]):
print(f" {n:4} {rows[n]}")
print(" deadline miss:", misses or "নেই")আসল আউটপুট (ব্রাউজারের Python):
RM (ছোট period = বড় priority)
012345678901
SENS #...#...#...
UI -##...##....
TELE ---#-#---#..
deadline miss: নেই
উল্টো ক্রম (TELE সবার ওপরে)
012345678901
TELE ###.........
UI ---##.##....
SENS -----#--##..
deadline miss: ['SENS@0', 'SENS@4']
RM-এর তিনটি সারি simulator-এর Gantt-এর সাথে অক্ষরে অক্ষরে মেলে। দ্বিতীয় অংশটি অংশ ৬-এর বিষয়। একটি সরলীকরণ: এই মডেল একই task-এর বকেয়া job-গুলোর কাজ একসাথে যোগ করে রাখে, আর miss গোনে পরের release-এর মুহূর্তে (এখানে deadline = period, তাই এতে চলে); rtos_sim.py প্রতিটি job আলাদা রাখে (Spec decision 34).
আসল RTOS “সবচেয়ে বড় priority” প্রতি tick-এ সব task ঘুরে খোঁজে না। FreeRTOS-এর Cortex-M3 port-এ একটি ৩২ বিটের word-এ প্রতিটি priority-র জন্য একটি বিট: সেই priority-তে কেউ ready থাকলে 1. তারপর একটি clz (count leading zeros) নির্দেশে ওপরের প্রথম 1 পাওয়া যায়, task যতই থাকুক (এই কৌশল চালু হয় configUSE_PORT_OPTIMISED_TASK_SELECTION 1 দিলে, আর তখন priority সর্বোচ্চ ৩২টি). নিচের C ব্লক cold room-এর schedule-এর ঘটনাগুলো এই বিট দিয়ে চালায়:
#include <stdio.h>
#include <stdint.h>
/* one task per priority here; a real RTOS keeps a list per priority */
static const char *name[4] = {"IDLE", "TELE", "UI", "SENS"};
static uint32_t ready = 1u; /* bit p: priority p is ready; IDLE always */
static void wake(int p) { ready |= (1u << p); }
static void block(int p) { ready &= ~(1u << p); }
static int pick(void) { return 31 - __builtin_clz(ready); }
static void show(const char *event)
{
printf("%-22s ready=", event);
for (int b = 3; b >= 0; b--)
putchar((ready >> b) & 1u ? '1' : '0');
printf(" run %s\n", name[pick()]);
}
int main(void)
{
wake(3); wake(2); wake(1); show("t=0 all released");
block(3); show("t=1 SENS done");
block(2); show("t=3 UI done");
wake(3); show("t=4 SENS released");
block(3); show("t=5 SENS done");
wake(2); show("t=6 UI released");
block(2); wake(3); show("t=8 UI done, SENS rel.");
block(3); show("t=9 SENS done");
block(1); show("t=10 TELE done");
return 0;
}আসল আউটপুট (Wandbox-এর compiler):
t=0 all released ready=1111 run SENS
t=1 SENS done ready=0111 run UI
t=3 UI done ready=0011 run TELE
t=4 SENS released ready=1011 run SENS
t=5 SENS done ready=0011 run TELE
t=6 UI released ready=0111 run UI
t=8 UI done, SENS rel. ready=1011 run SENS
t=9 SENS done ready=0011 run TELE
t=10 TELE done ready=0001 run IDLE
প্রতিটি লাইনের “run” simulator-এর Gantt-এর সাথে মেলে: tick 4-এ SENS-এর বিট 1 হতেই বাছাই TELE থেকে SENS-এ সরে যায়, আর সবশেষে শুধু idle-এর বিট বাকি। এই host program-এ __builtin_clz host CPU-র নির্দেশে চলে; Cortex-M3-এ এটি কী হয়, আমার lab-এ pick.c (একটি TCB struct, ready_bits আর pick_next) Clang দিয়ে দুটি target-এ compile করে দেখা হলো:
সত্যিকারের run — clang -S -O2, Clang 22.1.8 (ziglang 0.17.1)
--target=thumbv7m-none-eabi -mcpu=cortex-m3 --target=thumbv6m-none-eabi -mcpu=cortex-m0
pick_next: pick_next:
ldr r0, [r0] ldr r0, [r0]
cmp r0, #0 cmp r0, #0
itt eq beq .LBB0_2
moveq r0, #0 bl __clzsi2 @ library call
bxeq lr movs r1, #31
clz r0, r0 @ একটি নির্দেশ eors r1, r0
eor r0, r0, #31 ...
ldr.w r0, [r1, r0, lsl #2]
bx lr
(ঠিকানা বসানোর movw/movt লাইন বাদ।) Cortex-M3 (ARMv7-M)-এ clz একটি নির্দেশ; Cortex-M0 (ARMv6-M)-এ এই নির্দেশ নেই, তাই Clang একটি library function (__clzsi2) ডেকেছে। এ কারণেই FreeRTOS-এর ARMv6-M port-এ এই optimised বাছাই থাকে না, সেখানে সাধারণ C-র খোঁজ চলে। 31 − clz যে eor 31 হয়ে গেছে, সেটি compiler-এর কৌশল: 0 থেকে 31-এর মধ্যে দুটির ফল এক।
৬ · Rate monotonic — কাকে কোন priority
Priority বাছাইয়ের সহজাত প্রবৃত্তি “যে বেশি গুরুত্বপূর্ণ, সে আগে”. কিন্তু “গুরুত্ব” মাপা যায় না, সময় মাপা যায়। Rate-monotonic (RM) নিয়ম: যার period যত ছোট (যে যত ঘন ঘন আসে), তার priority তত বড়; deadline period-এর সমান ধরা হয়। Liu আর Layland ১৯৭৩ সালে দেখান, এমন periodic task-দের জন্য fixed-priority নিয়মগুলোর মধ্যে RM সেরা: কোনো fixed ক্রমে যদি সব deadline রাখা যায়, RM ক্রমেও যায়। Deadline period-এর চেয়ে ছোট হলে একই যুক্তির নাম deadline-monotonic: ছোট deadline, বড় priority (পর্ব ৪৩-এ ISR-এর priority এভাবেই বাছা হয়েছিল). OS-এর দৃষ্টিতে RM আর EDF-এর তত্ত্ব আছে Operating Systems পর্ব ২০-এ।
ধরুন একজন ভাবলেন, cloud-এ যায় বলে telemetry সবচেয়ে “বড়” কাজ, তাই TELE-কে দিলেন priority 3, SENS-কে 1. Task, C আর T একই; শুধু ক্রম উল্টো (cold_bad.json):
সত্যিকারের run — rtos_sim.py run cold_bad.json (TELE 3, UI 2, SENS 1; অংশ)
4 UI SENS released; DEADLINE MISS: SENS job released at 0 (deadline 4); (end of tick) UI finishes (response 5)
8 SENS SENS released; DEADLINE MISS: SENS job released at 4 (deadline 8); (end of tick) SENS finishes (response 5)
012345678901
TELE ###.........
UI ---##.##....
SENS -----#--##..
SENS released 0 start 5 finish 6 response 6 deadline 4 MISSED
SENS released 4 start 8 finish 9 response 5 deadline 8 MISSED
deadline misses: 2
ছবি ৫৬.২ — একই তিন task, দুই priority-ক্রম
রঙিন ঘর = চলছে, ধূসর দাগ = ready কিন্তু অপেক্ষায়, লাল ত্রিভুজ = deadline miss; দুটিই rtos_sim.py-এর সত্যিকারের run থেকে
| Tick | |
| RM: চলছে | |
| RM: SENS · UI · TELE | |
| উল্টো: চলছে | |
| উল্টো: TELE · UI · SENS | |
| উল্টো: miss |
- Tick 0. দুই run-এ তিনজনই ready. RM চালায় SENS (period 4), উল্টো ক্রম চালায় TELE (period 12).
- Tick 1–2. RM-এ UI চলে, SENS আগেই শেষ। উল্টো ক্রমে TELE তিন tick একটানা, আর SENS-এর ছোট্ট এক tick-এর কাজ অপেক্ষায়।
- Tick 3. RM-এ TELE শুরু করে। উল্টো ক্রমে UI (২) চলে; SENS (১) তখনও অপেক্ষায়।
- Tick 4: প্রথম miss. SENS-এর প্রথম job-এর deadline 4 এসে গেল, অথচ সে একবারও চলেনি: miss, আর দ্বিতীয় job-ও ছাড়া হলো। RM-এ এই মুহূর্তে SENS TELE-কে থামিয়ে চলছে।
- Tick 5. উল্টো ক্রমে SENS-এর প্রথম job অবশেষে চলে, 6-এ শেষ: response 6, deadline-এর ২ tick পরে। RM-এ TELE আবার চলছে।
- Tick 6–8: দ্বিতীয় miss. উল্টো ক্রমে UI-এর দ্বিতীয় job SENS-কে আবার ঠেলে পেছনে রাখে; tick 8-এ SENS-এর দ্বিতীয় job-এর deadline পেরোয়: miss ২টি। RM-এ UI চলে, তারপর SENS-এর তৃতীয় job সময়মতো।
- Tick 9–11: ফল। RM-এ TELE 10-এ শেষ, কোনো miss নেই। উল্টো ক্রমে SENS বকেয়া কাজ 9 আর 10-এ শেষ করে, কিন্তু ২টি deadline আগেই হারিয়েছে। Cold room-এ এর মানে তাপমাত্রার reading দেরিতে, আর alarm-এর ৩ reading-এর নিয়ম ভুল সময়ে গোনা।
কেন RM জেতে, তার সহজ যুক্তি: SENS-এর হাতে সময় মাত্র 4 tick, TELE-এর 12. TELE-কে আগে চালালে তার 3 tick-এর পরে SENS-এর হাতে বাকি থাকে 1 tick, যা UI খেয়ে ফেলে। TELE-কে পরে চালালে তার হাতে 12 tick-এর মধ্যে যথেষ্ট ফাঁক থাকে, যদিও সে বারবার থামে। ছোট সময়ের কাজকে আগে দিলে বড় সময়ের কাজের ক্ষতি হয় কম; উল্টোটায় হয় বেশি। “গুরুত্ব” তবু কাজে লাগে: সমান period-এর দুই task-এর মধ্যে, অথবা overload-এর সময় কে বাদ পড়বে তা ঠিক করতে।
৭ · দুই পরীক্ষা — Liu–Layland সীমা আর response-time analysis
Simulator-এ চালিয়ে দেখা একটি পরীক্ষা, প্রমাণ নয়: সব release একসাথে (critical instant) না হলে বা C কখনো বড় হলে কী হয়? তাই নকশার আগে হিসাব দিয়ে প্রমাণের দুটি পরীক্ষা আছে, যাকে বলে schedulability test.
১. Liu–Layland সীমা: n টি স্বাধীন periodic task, deadline = period, RM priority. যদি U = Σ Ci/Ti ≤ n(21/n − 1), তবে সব deadline নিশ্চিত। এটি যথেষ্ট শর্ত, প্রয়োজনীয় নয়: সীমার ওপরে গেলে উত্তর “জানি না”, “না” নয়। U > 1 হলে অবশ্য কোনো নিয়মেই সম্ভব নয় (পর্ব ৫৪).
২. Response-time analysis (RTA): প্রতিটি task i-এর সবচেয়ে খারাপ response, যখন সবাই একসাথে ছাড়া পায়:
Ri = Ci + Σj উঁচু ⌈Ri ÷ Tj⌉ × Cj
Ri সময়ের মধ্যে উঁচু priority-র task j ⌈Ri/Tj⌉ বার আসে, আর প্রতিবার Cj সময় খায়। R দুই পাশেই, তাই পুনরাবৃত্তি: R = C দিয়ে শুরু, বারবার ডান পাশ হিসাব, যতক্ষণ না মান আর বদলায় (তখন সেটিই উত্তর) বা deadline পেরোয় (তখন miss). পর্ব ৪৩-এ ISR-এর latency-র হিসাবে একই সূত্রের একটি রূপ ব্যবহার হয়েছে, সাথে blocking আর প্রবেশ-খরচ যোগ করে। নিচের ব্লক দুটি পরীক্ষাই চালায়:
from math import ceil, log
from fractions import Fraction
# ১) Liu–Layland সীমা n(2^(1/n) − 1)
for n in (1, 2, 3, 4, 5, 10):
print(f"n={n:2}: bound = {n * (2 ** (1 / n) - 1):.4f}")
print(f"n→∞ : ln 2 = {log(2):.4f}")
# ২) cold room-এর তিন task, RM ক্রমে (বড় priority আগে): (নাম, C, T)
tasks = [("SENS", 1, 4), ("UI", 2, 6), ("TELE", 3, 12)]
U = sum(Fraction(c, t) for _, c, t in tasks)
print(f"\nU = {U} = {float(U):.4f}")
# ৩) Response-time analysis: R = C + Σ ceil(R/Tj)·Cj, উঁচু priority-র j-এর ওপর
def rta(order):
for i, (name, c, t) in enumerate(order):
r, steps = c, [c]
while True:
nxt = c + sum(ceil(r / tj) * cj for _, cj, tj in order[:i])
steps.append(nxt)
if nxt == r or nxt > t:
break
r = nxt
verdict = "OK" if nxt <= t else "MISS"
print(f" {name:4} R: {' → '.join(map(str, steps))} (D={t}) {verdict}")
print("RM ক্রম:")
rta(tasks)
print("উল্টো ক্রম:")
rta(tasks[::-1])আসল আউটপুট (ব্রাউজারের Python):
n= 1: bound = 1.0000
n= 2: bound = 0.8284
n= 3: bound = 0.7798
n= 4: bound = 0.7568
n= 5: bound = 0.7435
n=10: bound = 0.7177
n→∞ : ln 2 = 0.6931
U = 5/6 = 0.8333
RM ক্রম:
SENS R: 1 → 1 (D=4) OK
UI R: 2 → 3 → 3 (D=6) OK
TELE R: 3 → 6 → 7 → 9 → 10 → 10 (D=12) OK
উল্টো ক্রম:
TELE R: 3 → 3 (D=12) OK
UI R: 2 → 5 → 5 (D=6) OK
SENS R: 1 → 6 (D=4) MISS
সীমা task বাড়লে নামে, n = 3-এ 0.7798, আর অসীমের দিকে ln 2 ≈ 0.6931-এ থামে। Cold room-এর U = 5/6 = 0.8333, সীমার ওপরে, তাই প্রথম পরীক্ষা কিছু বলতে পারে না। RTA বলে: RM ক্রমে R = 1, 3, 10, প্রতিটি নিজের deadline-এর (4, 6, 12) ভেতরে, তাই নিরাপদ। উল্টো ক্রমে SENS-এর হিসাব 1 → 6, deadline 4 পেরোল: miss. দুই ফলই simulator-এর run-এর সাথে মেলে (TELE 10-এ শেষ; উল্টো ক্রমে SENS-এর প্রথম response 6).
Reference lab-এর analyze একই হিসাব দেয় (Spec decision 36):
সত্যিকারের run — rtos_sim.py analyze cold_rm.json
tasks (highest priority first): SENS(C=1,T=4), UI(C=2,T=6), TELE(C=3,T=12)
U = 1/4 + 2/6 + 3/12 = 0.8333
Liu-Layland bound n(2^(1/n)-1) for n=3: 0.7798
U > bound but U <= 1: the bound test is inconclusive, use response-time analysis
R(SENS) = 1 (deadline 4) OK
R(UI) = 3 (deadline 6) OK
R(TELE) = 10 (deadline 12) OK
hyperperiod = 12 ticks
সত্যিকারের run — rtos_sim.py analyze cold_bad.json (দেওয়া ক্রম: TELE, UI, SENS; অংশ)
R(TELE) = 3 (deadline 12) OK
R(UI) = 5 (deadline 6) OK
R(SENS) = > 4 (deadline 4) MISS
দ্বিতীয় run-এর ওপরের লাইনগুলো (U আর সীমা) প্রথমটির মতোই, তাই বাদ দেওয়া। একটি সতর্কতা: tool-টি দেওয়া (RM নয়) ক্রমেও U আর Liu–Layland-এর লাইন ছাপে, আর U সীমার নিচে হলে সেই লাইনে “schedulable under RM” লেখে, এমনকি নিচে MISS থাকলেও। ওই লাইন শুধু RM ক্রমের কথা বলে; দেওয়া ক্রমের রায় সবসময় প্রতিটি task-এর R-এর লাইন। এবার TELE-এর পুনরাবৃত্তি ধাপে ধাপে:
| ধাপ | |
| আগের R | |
| SENS আসে | |
| UI আসে | |
| নতুন R |
- শুরু: R⁰ = C = 3. কেউ বাধা না দিলে TELE-এর লাগত তার নিজের 3 tick.
- R¹ = 6. প্রথম 3 tick-এ SENS একবার (1 tick) আর UI একবার (2 tick) আসে: 3 + 1 + 2 = 6.
- R² = 7. কিন্তু 6 tick লম্বা জানালায় SENS দুবার আসে (0 আর 4-এ): 3 + 2 + 2 = 7.
- R³ = 9. 7 tick-এর জানালায় UI-ও দুবার (0 আর 6-এ): 3 + 2 + 4 = 9.
- R⁴ = 10. 9 tick-এর জানালায় SENS তিনবার (0, 4, 8): 3 + 3 + 4 = 10.
- R⁵ = 10: থামল। 10 tick-এর জানালায় নতুন কেউ আসে না (SENS-এর পরের 12-এ, UI-এর 12-এ), তাই R আর বাড়ে না। R = 10 ≤ 12: নিরাপদ, আর simulator-এ TELE ঠিক 10-এ শেষ হয়েছিল।
সীমার ওপরে কিন্তু নিরাপদ, এমন set খুব সাধারণ। Period-গুলো পরস্পরের গুণিতক হলে (harmonic, যেমন 1, 2, 4 ms) RM-এ U = 1.0 পর্যন্তও নিরাপদ; reference lab-এর পরীক্ষায় (1, 2), (2, 4) এমন একটি set. উল্টো দিকে, U ≤ 1 হলেও RM-এ miss সম্ভব: rm_unschedulable.json-এ (C=3, T=6) আর (4, 9), U = 0.9444; তার হিসাব অনুশীলন ২-এ।
আরও গভীরে: RTA-র এই রূপ সাধারণত M. Joseph আর P. Pandya-র ১৯৮৬ সালের কাজ আর পরে N. Audsley-সহ York-এর গবেষকদের কাজের সাথে যুক্ত বলে উল্লেখ করা হয়; পরে এতে blocking (পর্ব ৫৭-এর mutex থেকে), release jitter আর context switch-এর খরচ যোগ হয়েছে। আসল নকশায় প্রতিটি C-তে দুটি context switch-এর সময় যোগ করা প্রচলিত, আর tick-এর ISR নিজেও একটি সবচেয়ে উঁচু “task”, যার C ছোট কিন্তু T খুব ছোট। Lehoczky, Sha আর Ding-এর ১৯৮৯ সালের একটি পরিচিত বিশ্লেষণে এলোমেলো task-set-এ RM গড়ে প্রায় ৮৮% ভার পর্যন্ত টিকেছে বলে উল্লেখ আছে; তাই ৬৯% সীমাটি নিরাপদ কিন্তু রক্ষণশীল।
পরীক্ষা ও ইন্টারভিউতে: “Rate monotonic কী?” → period ছোট, priority বড়; fixed-priority নিয়মগুলোর মধ্যে সেরা (deadline = period হলে). “Liu–Layland সীমা তিন task-এ?” → 3(21/3 − 1) ≈ 0.7798; অসীমে ln 2 ≈ 0.693; শুধু যথেষ্ট শর্ত। “U = 0.83 আর সীমা 0.78, schedulable?” → জানা যায় না; RTA চালান। “Blocked আর suspended-এর পার্থক্য?” → blocked ঘটনার অপেক্ষায়, নিজে জাগে; suspended কেউ resume না করা পর্যন্ত বাইরে। “Cortex-M-এ context switch কোথায়?” → PendSV handler-এ, সবচেয়ে কম জরুরি priority-তে; hardware আট word রাখে, RTOS r4–r11.
৮ · Task-প্রতি stack আর বাস্তব নকশার নিয়ম
পর্ব ৩৯-এ stack-এর হিসাব হয়েছিল একটি stack-এর জন্য, আর কথা দেওয়া হয়েছিল task-প্রতি হিসাব এখানে। নিয়মটি সরল: প্রতিটি task-এর stack = তার নিজের সবচেয়ে গভীর call-পথ (local, stack frame, ফেরার ঠিকানা) + থেমে থাকার সময়ের context (Cortex-M3, FPU ছাড়া: hardware-এর 8 word + RTOS-এর 8 word = 64 byte) + একটি মার্জিন। Interrupt-এর frame-ও task-এর stack-এ পড়ে, কিন্তু সেটি ওই 64 byte-এর ভেতরেই ধরা, আর nested handler-দের বাকি খরচ MSP-তে একবার।
| Task | গভীরতম পথ (ধরা মান) | + context | × 1.25 মার্জিন | FreeRTOS-এর word |
|---|---|---|---|---|
| SENS | 160 B | 224 B | 280 B | 70 |
| UI | 240 B | 304 B | 380 B | 95 |
| TELE (JSON বানানো) | 520 B | 584 B | 730 B | 183 (730 ÷ 4 = 182.5, ওপরে) |
| মোট | 280 + 380 + 730 = 1390 B, সাথে idle task, MSP-র stack আর প্রতিটি TCB | — | ||
গভীরতম পথের সংখ্যাগুলো এখানে ধরা মান, কোনো run-এর ফল নয়; আসল নকশায় এগুলো আসে compiler-এর stack-usage রিপোর্ট বা পর্ব ৩৯-এর মতো মাপ থেকে। মাপার জন্য FreeRTOS প্রতিটি নতুন task-এর stack একটি নকশা (0xA5) দিয়ে ভরে রাখে (পর্ব ৩৯-এর stack painting), আর uxTaskGetStackHighWaterMark জানায় কখনো-না-ছোঁয়া অংশ কত; configCHECK_FOR_STACK_OVERFLOW চালু করলে switch-এর সময় সীমা পেরোনো ধরার চেষ্টাও করে। বিশ KiB SRAM-এর chip-এ task যত বাড়ে, এই খাতটি তত দ্রুত বড় হয়; তাই ছোট firmware-এ কয়েকটি task-ই যথেষ্ট।
বাস্তব নকশার কয়েকটি নিয়ম, এই পর্বের হিসাব থেকে:
- Priority period বা deadline দেখে, গুরুত্ব দেখে নয় (RM বা deadline-monotonic); তারপর RTA দিয়ে প্রমাণ।
- প্রতিটি task-এর loop-এ একটি অপেক্ষা থাকতেই হবে (
xTaskDelayUntil, queue, semaphore). যে উঁচু priority-র task কখনো block করে না, সে নিচের সবাইকে চিরকাল আটকে রাখে: starvation, আর idle task-ও কখনো চলে না। - Priority-র স্তর কম রাখুন: FreeRTOS-এ
configMAX_PRIORITIESযত বড়, RAM তত বেশি। সমান period-এর কাজ এক স্তরে। - Tick-এর হার যুক্তি দিয়ে:
configTICK_RATE_HZ1000 মানে 1 ms-এর সূক্ষ্মতা, কিন্তু প্রতি ms-এ একটি ISR; cold room-এর 1 s আর 10 s-এর কাজে 100 Hz (10 ms)-ও যথেষ্ট, README-র SysTick-এর মতো। - ISR-এর ভার হিসাবে আনুন: ISR সব task-এর চেয়ে জরুরি, তাই প্রতিটি task-এর RTA-তে ISR-এর সময় যোগ হয়; ভারী কাজ ISR থেকে task-এ পাঠানোর নকশা পর্ব ৫৮ (RTOS-এর queue, event আর task-এর মধ্যে বার্তা)-এ।
৯ · AI-এর যুগে RTOS নকশা যাচাই
AI assistant-কে RTOS-এর task লিখতে বললে কোড প্রায়ই compile হয় আর বেঞ্চে চলে; ভুলগুলো থাকে সময়ের হিসাবে, যা কয়েক মিনিটের পরীক্ষায় ধরা পড়ে না। পরিচিত ভুলগুলো:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
| Priority-র দিক গুলিয়ে ফেলে: FreeRTOS-এ বড় সংখ্যা জরুরি, Cortex-M NVIC-এ ছোট সংখ্যা | RTOS-এর নিজের ডকুমেন্টেশন; প্রতিটি সংখ্যার পাশে “বড় = জরুরি?” লিখে রাখা |
| “গুরুত্বপূর্ণ” কাজকে সবচেয়ে উঁচু priority দেয়, period না দেখে | RM বা deadline-monotonic ক্রম আর RTA; simulator-এ উল্টো ক্রম চালিয়ে তুলনা |
Periodic task-এ vTaskDelay, ফলে drift | xTaskDelayUntil; দীর্ঘ সময় চালিয়ে release-এর সময় মেলানো (পর্ব ৫৪) |
| “U ≤ 1, তাই নিরাপদ” বা “সীমার ওপরে, তাই অসম্ভব” বলে | Liu–Layland শুধু যথেষ্ট শর্ত; RTA হাতে বা Python-এ |
| ISR থেকে সাধারণ blocking API ডাকে | ISR-এ শুধু “FromISR” API; RTOS-এর নিয়ম পড়া (পর্ব ৫৮) |
| Stack-এর মাপ byte ভেবে word-এর জায়গায় দেয়, বা উৎস ছাড়া সংখ্যা দেয় | API-র একক যাচাই; high-water mark মাপা; overflow-এর hook চালু রাখা |
প্রসঙ্গ, সংখ্যা আর যাচাইয়ের শর্ত শুরুতেই দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১১৯৬৯ সালে Apollo 11-এর চাঁদে নামার সময় guidance computer বারবার 1202 আর 1201 alarm দেয়, তবু অবতরণ সফল হয়। Priority-ভিত্তিক scheduling এখানে কী ভূমিকা রেখেছিল?
Apollo Guidance Computer (AGC)-এর software-এর কেন্দ্রে ছিল একটি ছোট “Executive”, যা কাজগুলোকে priority অনুযায়ী চালাত, আর নির্দিষ্ট সংখ্যক “core set” নামের জায়গায় কাজের অবস্থা রাখত। প্রচলিত বর্ণনা অনুযায়ী, অবতরণের সময় rendezvous radar-এর একটি সেটিংয়ের কারণে computer-এ অপ্রত্যাশিত বাড়তি কাজ (cycle stealing) আসছিল, ফলে CPU-র ভার সীমা ছাড়িয়ে যায় আর কাজ জমতে থাকে। জায়গা ফুরোলে Executive alarm দিয়ে software restart করত, এবং restart-এর পরে শুধু জরুরি কাজগুলো আবার শুরু হতো, কম জরুরি কাজ বাদ পড়ত। খুঁটিনাটি নিয়ে বিভিন্ন বর্ণনায় পার্থক্য আছে, কিন্তু মূল কথা সবাই একইভাবে বলেন: নকশাটি overload-এর মধ্যেও সবচেয়ে জরুরি কাজ (নামার নিয়ন্ত্রণ আর display) চালু রেখেছিল।
এই পর্বের ভাষায় ঘটনাটি পড়া যায়। একটি fixed-priority system-এ U হঠাৎ ১-এর ওপরে উঠলে কে ক্ষতিগ্রস্ত হয়? সবচেয়ে নিচের priority-র task. এটি fixed priority-র একটি বড় গুণ: overload-এর সময় আচরণ আগে থেকে বলা যায়। ক্ষতি পড়ে তালিকার নিচে, যাদের আপনি আগে থেকেই কম জরুরি ঘোষণা করেছেন। অংশ ৬-এর উল্টো ক্রমের run এর বিপরীত শিক্ষা দেয়: ক্রম ভুল হলে overload ছাড়াই সবচেয়ে ছোট সময়ের কাজটি হারায়।
আরেকটি শিক্ষা হলো restart-এর নকশা। AGC-র software বারবার restart হয়েও ঠিক জায়গা থেকে চলতে পারত, কারণ জরুরি অবস্থা আলাদা করে রাখা হতো। আজকের firmware-এ watchdog আর নিরাপদ পুনরারম্ভ (পর্ব ৬১) একই চিন্তার উত্তরসূরি। আর ঘটনাটি দেখায়, হিসাবের ভার (C) শুধু আপনার কোডের নয়: hardware-এর অপ্রত্যাশিত interrupt বা DMA-ও CPU-র সময় খায়, তাই RTA-তে ISR-এর ভার যোগ করা জরুরি।
মূল উপলব্ধি: Fixed-priority scheduling-এর শক্তি শুধু স্বাভাবিক সময়ে deadline রাখা নয়, overload-এর সময় কে আগে বাদ পড়বে তা আগে থেকে ঠিক করে রাখা। সেই তালিকা সাজাতে হয় সময় আর গুরুত্ব দুটোই ভেবে।
প্র ০২১৯৯০-এর দশকের শুরুর দিকের Windows 3.x আর পুরোনো Mac OS cooperative multitasking ব্যবহার করত, পরে সবাই preemptive-এ গেছে। তাহলে ছোট firmware-এ cooperative নকশা আজও কেন টিকে আছে?
Desktop-এ cooperative multitasking-এর দুর্বলতা সবাই দেখেছেন: একটি program loop-এ আটকে গেলে বা CPU ছাড়তে ভুলে গেলে পুরো computer থেমে যেত, কারণ OS তাকে থামাতে পারত না। Windows 95 ৩২ বিটের program-এর জন্য preemptive multitasking আনে, আর Apple-এর ক্ষেত্রে পূর্ণ preemptive multitasking সাধারণ মানুষের হাতে আসে ২০০১ সালের Mac OS X-এ। Desktop-এ কারণটা স্পষ্ট ছিল: হাজারো অচেনা লেখকের program একসাথে চলে, আর কাউকে বিশ্বাস করা যায় না যে সে সময়মতো CPU ছাড়বে।
একটি ছোট firmware-এর অবস্থা আলাদা। সব কোড একজন বা একটি দলের লেখা, task-এর সংখ্যা হাতে গোনা, আর প্রতিটি task-এর সবচেয়ে লম্বা টুকরো মাপা যায়। তখন cooperative-এর সুবিধাগুলো বড় হয়ে ওঠে। Task শুধু নির্দিষ্ট জায়গায় বদলায়, তাই দুটি task-এর ভাগ করা data-য় mutex প্রায়ই লাগে না; একটি stack-ই অনেক সময় যথেষ্ট (যেমন protothread-ধাঁচের নকশায়); আর context switch কম। পর্ব ৫৫-এর super loop আর task table এই ঘরানার।
দাম কোথায়, তা অংশ ৪-এর run-এ মাপা: TELE-এর কাজ 5 tick হলে cooperative-এ SENS-এর একটি deadline গেছে, একই ভারে preemptive-এ যায়নি। Cooperative-এ প্রতিটি task-এর সবচেয়ে লম্বা টুকরোটি অন্য সবার response-এ যোগ হয়, তাই নিয়মটি দাঁড়ায়: প্রতিটি টুকরোর WCET সবচেয়ে ছোট deadline-এর তুলনায় ছোট রাখা। কোড বদলালে, নতুন library এলে, বা কেউ একটি blocking I2C পড়া যোগ করলে এই শর্ত নীরবে ভাঙতে পারে। Preemptive নকশা সেই দায় scheduler-কে দেয়, বিনিময়ে ভাগ করা data-র সুরক্ষা (পর্ব ৫৭) আর task-প্রতি stack-এর খরচ।
মূল উপলব্ধি: Cooperative বা preemptive বাছাই আসলে এই প্রশ্ন: সময়ের নিশ্চয়তার দায় কে নেবে, প্রতিটি task-এর লেখক না scheduler? ছোট, স্থির, এক দলের firmware-এ প্রথমটি চলে; বাড়তে থাকা জটিল firmware-এ দ্বিতীয়টি নিরাপদ।
প্র ০৩EDF এক CPU-তে U = 1 পর্যন্ত সব deadline রাখতে পারে, RM-এর নিশ্চিত সীমা প্রায় ৬৯ শতাংশ। তবু বেশিরভাগ বাণিজ্যিক RTOS fixed priority দেয়। কেন?
EDF (Earliest Deadline First) প্রতি মুহূর্তে যে job-এর deadline সবচেয়ে কাছে, তাকে চালায়; priority তাই job-এর সাথে বদলায়। তত্ত্বে এটি এক CPU-তে সেরা: deadline = period হলে U ≤ 1 মানেই schedulable. Liu আর Layland-এর ১৯৭৩ সালের একই প্রবন্ধে RM আর এই deadline-ভিত্তিক নিয়ম দুটিই আলোচিত। তাহলে FreeRTOS-এর মতো kernel-এ শুধু fixed priority কেন?
প্রথম কারণ বাস্তবায়ন। Fixed priority-তে বাছাই একটি বিট-ম্যাপ আর একটি clz; অংশ ৫-এ Cortex-M3-এ এটি কয়েকটি নির্দেশ। EDF-এ প্রতিটি release-এ deadline-এর সারি সাজাতে হয়, আর tick-এর গোনা wrap হলে তুলনায় সাবধান হতে হয়। দ্বিতীয় কারণ overload-এর আচরণ। Fixed priority-তে overload হলে ক্ষতি পড়ে নিচের priority-তে, যা আগে থেকে জানা (প্র ০১). EDF-এ overload হলে প্রায় যেকোনো task-এর deadline যেতে পারে, এমনকি একটি domino-র মতো পরপর অনেকগুলো। তৃতীয় কারণ অভ্যাস আর hardware: interrupt controller-রাও fixed priority-তে চলে, তাই ISR আর task একই ভাষায় ভাবা যায়, আর certification ও বিশ্লেষণের tool-গুলো দীর্ঘদিন fixed priority ঘিরে তৈরি।
তবে বিতর্কটি একতরফা নয়। Giorgio Buttazzo-র ২০০৫ সালের একটি পরিচিত প্রবন্ধ (“Rate Monotonic vs. EDF: Judgment Day”) যুক্তি দেয় যে EDF-এর বিরুদ্ধে প্রচলিত কয়েকটি ধারণা অতিরঞ্জিত, আর EDF context switch-ও কম ঘটাতে পারে। Linux-এ SCHED_DEADLINE নামে EDF-ভিত্তিক একটি নীতি আছে। আর সীমার প্রশ্নে: ৬৯% হলো নিশ্চিত সীমা, বাস্তবের সীমা নয়; অংশ ৭-এর cold room U = 0.8333-এ, আর harmonic period-এ U = 1.0-এ RM নিরাপদ।
মূল উপলব্ধি: RTOS-এর নকশায় তাত্ত্বিক সর্বোচ্চ ভারের চেয়ে বেশি দামি সরল বাস্তবায়ন, আগে থেকে বলা যায় এমন overload আর পরিচিত বিশ্লেষণ। তাই fixed priority আর RM, যার দুর্বলতা RTA দিয়ে অনেকটাই ঢাকা যায়।
প্র ০৪Cortex-M3-এর নকশায় ARM PendSV আর SVC নামের exception রেখেছিল, আর দুটি stack pointer. এক কথায় বললে, এগুলো RTOS-কে কী সুবিধা দেয়, যা 8085 বা ARM7-এর মতো পুরোনো CPU দিত না?
পুরোনো CPU-তে একটি RTOS-কে context switch পুরোটাই software-এ করতে হতো: interrupt-এর ভেতরে সব register হাতে রাখা, অন্য task-এর stack-এ যাওয়া, আর ফেরার কৌশল প্রতিটি port-এ আলাদা। সবচেয়ে কঠিন ছিল প্রশ্নটি: switch ঠিক কখন? যদি একটি ISR nested অবস্থায় চলে, আর ভেতরের ISR-এ switch হয়, তাহলে বাইরের ISR-এর অর্ধেক কাজ অন্য task-এর stack-এ চলে যেতে পারে।
২০০৪–০৫ সালে আসা Cortex-M3 এই সমস্যাগুলো architecture-এর স্তরে ধরে। প্রথমত, hardware stacking: exception-এ ঢোকার সময় আট word CPU নিজে রাখে, তাই RTOS-এর কাজ অর্ধেক। দ্বিতীয়ত, PSP আর MSP: task-রা PSP-তে, handler-রা MSP-তে, তাই ISR-এর nested খরচ প্রতিটি task-এর stack-এ রাখতে হয় না। তৃতীয়ত, PendSV: একটি software-এ pending করা exception, যাকে সবচেয়ে কম জরুরি priority দিলে সে চলে সব ISR শেষ হওয়ার পরে। ফলে যত ISR-ই switch চাক, switch হয় একবার, ঠিক thread mode-এ ফেরার মুখে। আর SVC দেয় task থেকে kernel-এ ঢোকার একটি নিয়ন্ত্রিত দরজা, যা FreeRTOS-এর Cortex-M3 port প্রথম task চালু করতে ব্যবহার করে।
এই পর্বের Clang-এর run একটি ছোট উদাহরণ দেখায় কীভাবে architecture-এর পার্থক্য RTOS-এর ভেতরে ঢোকে: Cortex-M3-এ ready task খোঁজা একটি clz, Cortex-M0-এ একটি library call. একইভাবে Cortex-M0-তে BASEPRI নেই, তাই সেখানে RTOS-এর critical section সব interrupt বন্ধ করে (পর্ব ৪৩-এর “আরও গভীরে”). কোর্সের board এই অংশগুলো মডেল করে না (Spec decision 19); তাই এখানে context switch চালিয়ে দেখানো যায়নি, শুধু ধাপগুলো উৎস-কোড থেকে।
মূল উপলব্ধি: Cortex-M-এর exception মডেল একটি RTOS-এর context switch-কে প্রায় স্বাভাবিক interrupt-এ পরিণত করে: থেমে থাকা task একটি interrupt-এর frame, চলা শুরু মানে সেখান থেকে ফেরা, আর কখন switch তা ঠিক করে priority-র নিয়ম।
প্র ০৫FreeRTOS-এ time slicing চালু থাকলে সমান priority-র task-রা প্রতি tick-এ পালা বদলায়। একটি firmware-এ কখন কয়েকটি task-কে সমান priority দেওয়া ভালো, আর কখন বিপদ?
Round-robin-এর ভালো দিক অংশ ৪-এ মাপা: সমান priority-র তিন task, প্রত্যেকে 3 tick, quantum 1 বা 2-এ সবাই প্রায় একসাথে এগোয়, কেউ একা অনেকক্ষণ আটকে থাকে না। তাই যেসব কাজের কোনো কঠিন deadline নেই, কিন্তু প্রত্যেকের কিছুটা অগ্রগতি দরকার, যেমন একটি log ফাইলে লেখা, একটি debug console আর একটি পটভূমির checksum, সেগুলোকে এক নিচু স্তরে রেখে time slicing দেওয়া যুক্তিসঙ্গত। এতে priority-র স্তরও বাঁচে, আর FreeRTOS-এ স্তর কম মানে RAM কম।
বিপদ তিন রকম। এক, deadline-এর হিসাব জটিল হয়: সমান priority-র task-এর response-এ অন্যদের পুরো কাজ ঢুকে যেতে পারে, তাই RTA-তে সমান স্তরের সবাইকে বাধা হিসেবে ধরতে হয়। অংশ ৪-এর run-এ quantum 2-এ A-র response 3 থেকে বেড়ে 7. দুই, প্রতি tick-এ একটি context switch: ছোট CPU-তে এই খরচ নগণ্য নয়, আর cache বা flash-এর prefetch থাকলে আরও বেশি। তিন, ভুল ধারণা: “সমান priority দিলে সবাই ন্যায্য সময় পাবে” কথাটি সত্য শুধু যদি সবাই সবসময় ready থাকে; একটি task বারবার block করলে সে তার slice-এর বাকি অংশ হারায়।
আরেকটি সূক্ষ্ম কথা idle task নিয়ে। FreeRTOS-এ idle task priority 0-এ থাকে, আর মুছে ফেলা task-এর memory ফেরত দেওয়ার মতো কিছু কাজ তার দায়িত্বে। কোনো application task-কে 0 দিলে আর time slicing চালু থাকলে সে idle-এর সাথে পালা ভাগ করে; কিন্তু সে যদি কখনো block না করে আর slicing বন্ধ থাকে, idle হয়তো চলার সুযোগই পাবে না। নিয়মটি তাই: প্রতিটি task-এর loop-এ একটি অপেক্ষা, আর সমান স্তর শুধু সত্যিই সমান গুরুত্বের, deadline-হীন কাজের জন্য।
মূল উপলব্ধি: Time slicing ন্যায্যতার যন্ত্র, সময়ের নিশ্চয়তার নয়। জরুরি কাজ আলাদা উঁচু স্তরে, RM দিয়ে সাজানো; সমান স্তরে শুধু পটভূমির কাজ, আর সেখানেও প্রত্যেকে নিজে থেকে block করে।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। Schedule আর হিসাব কোর্সের rtos_sim.py-এ বা Python-এ চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — TELE task: Cold room-এর TELE task FreeRTOS-এ লিখুন: প্রতি 10 s-এ একবার, drift ছাড়া, শেষ reading নিয়ে
TELEMETRY {"dev":"coldroom-1","seq":…}-ধাঁচের লাইন বানিয়ে পাঠাবে, আর কোনো পাক দেরিতে শুরু হলে একটি counter বাড়াবে। RM নিয়মে SENS (1 s), UI আর TELE-এর মধ্যে TELE কোন priority পাবে, আর কেন?static uint32_t tele_late; /* দেরিতে শুরু হওয়া পাক */ static void tele_task(void *arg) { (void)arg; uint32_t seq = 0; TickType_t last = xTaskGetTickCount(); for (;;) { BaseType_t on_time = xTaskDelayUntil(&last, pdMS_TO_TICKS(10000)); if (on_time == pdFALSE) /* ঘুমাতে হয়নি: দেরি */ tele_late++; reading_t r = latest_reading(); /* SENS-এর শেষ মান */ send_telemetry(++seq, r.temp_c100, r.alarm); } } /* xTaskCreate(tele_task, "TELE", 183, NULL, 1, NULL); */উদাহরণ, চালানো হয়নি।
xTaskDelayUntilপরের জাগার সময় আগের জাগার সময় থেকে গোনে, তাই drift নেই (পর্ব ৫৪); FreeRTOS-এরtask.h-এর বর্ণনা অনুযায়ী task-কে সত্যিই অপেক্ষা করতে না হলে (সময় ইতিমধ্যে পেরিয়ে গেলে) এটিpdFALSEফেরায়, তাই সেটিই দেরির সংকেত। Priority: TELE-এর period (10 s) সবচেয়ে বড়, তাই RM-এ সবচেয়ে নিচু, 1 (SENS 3, UI 2). এটি অংশ ৬-এর শিক্ষা: cloud-এ যায় বলে বড় মনে হলেও সময়ের দিক থেকে TELE-এর হাতে সবচেয়ে বেশি সময়।latest_reading()দুই task-এর ভাগ করা data পড়ে; সেটি নিরাপদে করার উপায় (mutex বা queue) পর্ব ৫৭ আর ৫৮-এ। -
ভুল খুঁজুন — দুই সহকর্মীর রায়: দুটি task, RM priority: T1 (C = 3, T = 6), T2 (C = 4, T = 9), deadline = period. সহকর্মী ক বললেন, “U = 0.9444 > 0.8284, তাই এই set কখনোই schedulable নয়।” সহকর্মী খ বললেন, “U ≤ 1, তাই নিশ্চয়ই schedulable.” দুজনের যুক্তির ভুল কোথায়, আর সঠিক উত্তর কী?
দুজনেই ভুল যুক্তিতে। ক-এর ভুল: Liu–Layland সীমা যথেষ্ট শর্ত, প্রয়োজনীয় নয়; সীমার ওপরে গেলে শুধু বলা যায় “এই পরীক্ষা কিছু বলতে পারে না”. খ-এর ভুল: U ≤ 1 প্রয়োজনীয় শর্ত, যথেষ্ট নয় (EDF-এর জন্য যথেষ্ট, fixed priority-র জন্য নয়). সঠিক পথ RTA. T1: R = 3 ≤ 6. T2: R⁰ = 4; R¹ = 4 + ⌈4/6⌉×3 = 7; R² = 4 + ⌈7/6⌉×3 = 10 > 9: miss. Reference lab-এর run একই কথা বলে:
সত্যিকারের run — rtos_sim.py analyze rm_unschedulable.json (অংশ) U = 3/6 + 4/9 = 0.9444 Liu-Layland bound n(2^(1/n)-1) for n=2: 0.8284 U > bound but U <= 1: the bound test is inconclusive, use response-time analysis R(T1) = 3 (deadline 6) OK R(T2) = > 9 (deadline 9) MISS সত্যিকারের run — rtos_sim.py run rm_unschedulable.json --no-trace (অংশ) T1 ###...###...###... T2 ---###---###---##. T2 released 0 start 3 finish 10 response 10 deadline 9 MISSEDসুতরাং উত্তর “schedulable নয়”, ক-এর সিদ্ধান্ত মিলে গেছে, কিন্তু ভুল যুক্তিতে; ঠিক এই U-তে অন্য period-এ (যেমন harmonic) উত্তর উল্টো হতে পারত।
-
Trace — আগে অনুমান, পরে মেলান: Cooperative scheduler, তিন task (C, T): SENS (1, 4), UI (2, 6), TELE (5, 12); priority SENS 3, UI 2, TELE 1; কেউ yield করে না, সবাই tick 0-তে ছাড়া পায়, deadline = period. 0 থেকে 11 tick-এর Gantt আঁকুন। কোন job-এর deadline যায়? একই set preemptive fixed priority-তে চালালে কী হয়?
হাতে: tick 0-এ SENS (সবচেয়ে উঁচু), 1–2 UI, 3-এ TELE শুরু, আর cooperative বলে 3 থেকে 7 পর্যন্ত একটানা। SENS-এর দ্বিতীয় job (release 4, deadline 8) চলতে পারে শুধু 8-এ, শেষ 9-এ: miss. Simulator-এর run:
সত্যিকারের run — rtos_sim.py run cold_coop.json (অংশ) SENS #...----##.. UI -##...----## TELE ---#####.... SENS released 4 start 8 finish 9 response 5 deadline 8 MISSED UI released 6 start 10 finish 12 response 6 deadline 12 met deadline misses: 1UI-এর দ্বিতীয় job-ও টানাটানিতে: response 6, deadline-এর ঠিক সমান। Preemptive-এ (
cold_rm5.json) কোনো miss নেই, TELE শেষ 12-এ, U = 1.0000. RTA-ও তাই বলে: R = 1, 3, 12. শিক্ষা: cooperative-এ সবচেয়ে লম্বা টুকরোটি (এখানে TELE-এর 5 tick) সবচেয়ে ছোট deadline-এর (4) চেয়ে বড় হলেই বিপদ। -
হিসাব — task-প্রতি stack: একটি Cortex-M3 (FPU নেই)-এ চারটি task: গভীরতম call-পথ 96 B, 200 B, 400 B আর idle-এর 64 B. প্রতিটির সাথে context-এর 64 B যোগ করে 25% মার্জিন দিন। FreeRTOS-এর
xTaskCreate-এ প্রতিটির জন্য কত word লিখবেন, আর মোট কত byte?ধাপ: (পথ + 64) × 1.25, তারপর ৪ দিয়ে ভাগ করে ওপরে গোল।
- 96 + 64 = 160 B → × 1.25 = 200 B → 50 word.
- 200 + 64 = 264 B → 330 B → 82.5, তাই 83 word (332 B).
- 400 + 64 = 464 B → 580 B → 145 word.
- 64 + 64 = 128 B → 160 B → 40 word.
মোট 50 + 83 + 145 + 40 = 318 word = 1272 B, TCB আর MSP-র stack ছাড়া। দুটি সতর্কতা: “context 64 B” শুধু FPU-হীন Cortex-M3-এর জন্য (FPU-ওয়ালা M4F-এ অনেক বেশি), আর call-পথের মাপ অনুমান নয়, compiler-এর রিপোর্ট বা high-water mark দিয়ে যাচাই করতে হয়। হিসাবটি Python-এ চালিয়ে মেলানো।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি Cortex-M3-এ FreeRTOS চলছে। নিচু priority-র task L চলার সময় tick আসে আর উঁচু priority-র task H-এর অপেক্ষা শেষ হয়। Switch-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Hardware L-এর PSP-তে আট word রাখে আর SysTick handler-এ ঢোকে
- Tick handler H-কে ready করে আর PendSV pending করে
- SysTick ফেরার মুখে PendSV tail-chain করে ঢোকে
- PendSV L-এর r4–r11 রেখে তার stack-এর মাথা L-এর TCB-তে লেখে
- Scheduler ready-দের মধ্যে সবচেয়ে বড় priority, H, বাছে
- H-এর r4–r11 তুলে PSP বসিয়ে ফেরা; hardware বাকি আট word তোলে
একটি FreeRTOS firmware-এ task A-র priority 3, task B-র 1, দুজনেই ready; preemption চালু। আর একটি Cortex-M chip-এর NVIC-এ interrupt X-এর priority 3, Y-এর 1, দুজনেই pending. কে আগে চলে?
- A আর X
- B আর X
- A আর Y
- B আর Y
তিনটি periodic task, deadline = period: ADC-র গড় (period 20 ms), alarm-এর যাচাই (period 5 ms), log লেখা (period 100 ms). Rate-monotonic নিয়মে priority-র ক্রম (সবচেয়ে উঁচু আগে) কী?
- log, ADC, alarm
- alarm, ADC, log
- ADC, alarm, log
- তালিকায় যে ক্রমে আছে: ADC, alarm, log
তিনটি task-এর U = 1/4 + 2/6 + 3/12 = 0.8333; তিন task-এর Liu–Layland সীমা 0.7798. Priority RM অনুযায়ী, deadline = period. কোন সিদ্ধান্ত সঠিক?
- সীমা পেরিয়েছে, তাই অন্তত একটি deadline যাবেই
- U ≤ 1, তাই কোনো হিসাব ছাড়াই নিরাপদ
- একটি task বাদ দিলে তবেই বলা যাবে
- এই পরীক্ষা অমীমাংসিত; response-time analysis চালাতে হবে (এখানে R = 1, 3, 10, তাই নিরাপদ)
Task T (C = 3)-এর ওপরে দুটি উঁচু priority-র task: (C = 1, T = 4) আর (C = 2, T = 6); সবাই একসাথে ছাড়া পায়। Response-time analysis-এ T-এর R কত?
- 10
- 6
- 9
- 12
FPU-হীন Cortex-M3-এ FreeRTOS-এর PendSV handler context switch-এর সময় software দিয়ে কোন register-গুলো task-এর stack-এ রাখে?
- R0–R3, R12, LR, PC আর xPSR
- R0 থেকে R15, সবগুলো
- r4–r11
- শুধু MSP আর PSP
তিনটি task, priority SENS > UI > TELE, (C, T) = (1, 4), (2, 6), (5, 12), সবাই tick 0-তে ছাড়া পায়, U = 1.0. Scheduler cooperative (কেউ yield করে না) হলে আর preemptive fixed priority হলে প্রথম 12 tick-এ কী ঘটে?
- দুই নীতিতেই miss, কারণ U = 1.0
- শুধু cooperative-এ SENS-এর একটি deadline যায়; preemptive-এ কেউ miss করে না
- শুধু preemptive-এ TELE-এর deadline যায়
- কোনো নীতিতেই miss নেই
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Task = নিজের stack-ওয়ালা অসীম loop + TCB; অবস্থা running, ready, blocked (ঘটনার অপেক্ষা), suspended (resume-এর অপেক্ষা). প্রতিটি loop-এ একটি অপেক্ষা চাই।
- Cortex-M-এর context switch: hardware আট word, RTOS PendSV-এ r4–r11; PendSV সবচেয়ে কম জরুরি, তাই switch সব ISR-এর পরে একবার। Ready task খোঁজা M3-এ একটি
clz. - নীতি: preemptive fixed priority মূল; round-robin শুধু সমান priority-র ভেতরে, ন্যায্যতার জন্য; cooperative-এ সবচেয়ে লম্বা টুকরো সবার response-এ যোগ হয়।
- RM: period ছোট, priority বড়। ক্রম ভুল হলে একই U-তে deadline যায় (cold room-এ উল্টো ক্রমে ২টি miss).
- Liu–Layland যথেষ্ট, RTA নির্ভুল: সীমা n(21/n − 1), তিন task-এ 0.7798; ওপরে গেলে R = C + Σ⌈R/Tj⌉Cj পুনরাবৃত্তি। Task-প্রতি stack = গভীরতম পথ + 64 B context + মার্জিন।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ৫৪ · Real-time system — hard বনাম soft deadline আর WCETআগের ভিত্তিDeadline, WCET, jitter, drift আর utilisation: এই পর্বের হিসাবের ভাষা।
- পর্ব ৩০ · Cortex-M-এর exception আর NVICআগের ভিত্তিআট word-এর stacking, EXC_RETURN আর tail-chaining: context switch-এর যন্ত্র।
- পর্ব ৩৯ · এমবেডেড memory আর stackআগের ভিত্তিStack-এর আকার, painting আর high-water mark; task-প্রতি হিসাবের ভিত্তি।
- Operating Systems পর্ব ২০ · Multiprocessor আর real-time schedulingপাশের ট্র্যাকRM, EDF আর Liu–Layland সীমা, OS-এর দৃষ্টিতে।