সরাসরি পর্বে যান
পর্ব ৫৪ · ৮৫-এর মধ্যে · মডিউল ৯

Real-time system — hard বনাম soft deadline আর WCET

Real-Time Systems — Hard vs Soft Deadlines and WCET

Taught in Bangla, this lesson defines real-time as guaranteed timing and classifies hard, firm and soft deadlines. It models tasks by release, C, T and D, and the course's rtos_sim shows a sporadic job making a periodic task miss its deadline (response 6, deadline 5). On the virtual BG-M3 board a cold-room job measures 886 cycles on one script and 1155 on another, showing that measurement only bounds WCET from below. A measured alarm latency of 2001.06 and 2999.06 ms matches the budget, and utilisation is computed.

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

  • Hard, firm আর soft deadline আলাদা করা, আর একটি যন্ত্রের প্রতিটি কাজের deadline কোন শ্রেণির তা যুক্তি দিয়ে বলা
  • Periodic, aperiodic আর sporadic task-এর মডেল: release, C, T, D, response time আর deadline miss
  • Jitter আর drift মাপা ও আলাদা করা, আর পরম সময়ে release দিয়ে drift বন্ধ করা
  • WCET অনুমানের দুই পথ, মাপা আর হিসাব, প্রতিটির সীমাসহ; board-এ execution time মাপা
  • একটি end-to-end latency budget আর utilisation-এর যোগফল হাতে ও Python-এ হিসাব করা

১ · Real-time মানে কী — deadline-এর তিন রকম

পর্ব ০৪-এ আপনি real-time শব্দটির সঙ্গে পরিচিত হয়েছেন: উত্তর ঠিক হওয়াই যথেষ্ট নয়, ঠিক সময়ে আসতে হবে। এই পর্ব থেকে মডিউল ৯ শুরু, যার পুরোটাই সময় নিয়ে। এখানে আমরা সেই কথাকে সংখ্যায় আনব: কোন কাজের deadline কত, সবচেয়ে খারাপ অবস্থায় কাজটি কত সময় নেয়, আর CPU সব কাজ সামলাতে পারবে কি না। এই পর্বে hex লেখা হবে C-ধাঁচে, 0x….

একটি real-time system-এ প্রতিটি কাজের একটি deadline থাকে: যে মুহূর্তের মধ্যে ফল আসতেই হবে। “Real-time” মানে “খুব দ্রুত” নয়। বাজারঘরের cold-storage monitor প্রতি 1 s-এ একবার তাপমাত্রা পড়ে; একটি 8 MHz-এর MCU-র কাছে এক সেকেন্ড অনন্তকাল। তবু এটি real-time, কারণ নকশা প্রতিশ্রুতি দেয় যে প্রতিটি reading সময়মতো হবে আর alarm একটি জানা সময়ের মধ্যে বাজবে।

উপমা — রেলস্টেশনের ঘোষণা: কমলাপুরে “সুবর্ণ এক্সপ্রেস ৩ নম্বর প্ল্যাটফর্মে আসছে” ঘোষণা ট্রেন ঢোকার আগে হতে হবে। ট্রেন চলে যাওয়ার পরে ঘোষণা যতই স্পষ্ট হোক, তার কোনো দাম নেই। আবার ঘোষণাকারীকে তাড়াহুড়ো করে প্রতি সেকেন্ডে কথা বলতে হয় না; শুধু প্রতিটি ঘোষণা নিজের deadline-এর আগে হলেই চলে। Real-time নকশা মানে এই নিশ্চয়তা: গড়ে নয়, প্রতিবার।

Deadline পেরোলে কী ক্ষতি হয়, সেটি দিয়েই তিন শ্রেণি। একই যন্ত্রের ভেতরে আলাদা কাজ আলাদা শ্রেণির হতে পারে, তাই শ্রেণিটি যন্ত্রের নয়, প্রতিটি deadline-এর:

শ্রেণিDeadline পেরোলেবাজারঘর আর চেনা উদাহরণ
Hardএকবার পেরোলেই ব্যর্থতা; ক্ষতি বড় বা অপূরণীয়গাড়ির airbag, motor-এর overcurrent কাটা; বাজারঘরে কাছাকাছি: UART-এর byte 86.8 µs-এর মধ্যে না পড়লে হারায় (পর্ব ৪৯)
Firmদেরির ফল মূল্যহীন, ফেলে দেওয়া হয়; মাঝেমধ্যে সহ্য করা যায়Cold room-এর ১ s-এর reading: পরের reading এসে গেলে আগেরটি অর্থহীন, কিন্তু একটি বাদ পড়লে খাবার নষ্ট হয় না
Softদেরি হলে মান কমে, ফল তবু কাজে লাগেপ্রতি 10 s-এর telemetry dashboard-এ এক সেকেন্ড দেরিতে পৌঁছানো; ভিডিও কলের একটি frame

খেয়াল করুন, শ্রেণি ঠিক হয় পরিণাম দিয়ে, সময়ের মাপ দিয়ে নয়। Cold room-এর alarm-এর deadline সেকেন্ডের, অথচ alarm একেবারে না বাজলে লক্ষ টাকার মাছ-মাংস নষ্ট হতে পারে। তাই alarm-এর সবচেয়ে খারাপ দেরির একটি প্রতিশ্রুতি থাকা দরকার (অংশ ৫). অন্যদিকে UART-এর deadline মাইক্রোসেকেন্ডের, কিন্তু একটি কমান্ডের byte হারালে ব্যবহারকারী আবার পাঠান; ক্ষতি ছোট। দ্রুততা আর গুরুত্ব দুটি আলাদা মাত্রা, আর priority বাছাইয়ে এই দুটি গুলিয়ে ফেলার ফল পর্ব ৪৩-এ মাপা হয়েছে।

মূল নিয়ম Real-time নকশায় গড় নয়, সবচেয়ে খারাপ অবস্থা প্রমাণ করতে হয়। “সাধারণত 2 ms লাগে” কোনো প্রতিশ্রুতি নয়; “কখনো 3 ms-এর বেশি লাগে না, কারণ …” প্রতিশ্রুতি।

২ · Task-এর মডেল — periodic, aperiodic আর sporadic

সময়ের হিসাব করতে হলে প্রতিটি কাজকে কয়েকটি সংখ্যায় লিখতে হয়। একটি task বারবার আসে; প্রতিবারের আসাকে বলে একটি job. প্রতিটি job-এর চারটি সংখ্যা:

  • Release (r): যে মুহূর্তে job চলার জন্য তৈরি হয়, যেমন SysTick-এর 100তম tick.
  • C: job-টির নিজের কাজের সময়, অন্য কেউ বাধা না দিলে। সবচেয়ে খারাপটি WCET, সবচেয়ে ভালোটি BCET.
  • T: দুই release-এর ব্যবধান (periodic) বা ন্যূনতম ব্যবধান (sporadic).
  • D: আপেক্ষিক deadline; job-কে r + D-এর মধ্যে শেষ হতে হবে। প্রায়ই D = T.

Job শেষ হওয়ার মুহূর্ত বিয়োগ release হলো response time R. R-এ C ছাড়াও থাকে অপেক্ষা: বেশি জরুরি কাজের বাধা আর শুরুর দেরি। নিয়মটি সরল: R ≤ D হলে deadline রক্ষা।

আসার ধরন অনুযায়ী task তিন রকম। Periodic task ঘড়ির তালে আসে: cold room-এর reading, প্রতি 1 s. Aperiodic task যেকোনো সময় আসে, দুই আসার মাঝে কোনো নিশ্চিত ব্যবধান নেই: যেমন একটি বিরল debug কমান্ড। Sporadic task-ও ঘটনায় আসে, কিন্তু দুই আসার মাঝে একটি ন্যূনতম ব্যবধান জানা: scale-এর tare বোতাম। Debounce (পর্ব ৪২) থাকায় দুটি স্বীকৃত চাপের মাঝে কয়েক ms থাকবেই। এই ন্যূনতম ব্যবধানই sporadic task-কে হিসাবযোগ্য করে: সবচেয়ে খারাপ অবস্থায় সে ওই ব্যবধানে আসা একটি periodic task-এর মতো আচরণ করে। Aperiodic task-এর এমন সীমা নেই, তাই hard deadline-এর হিসাবে তাকে সরাসরি রাখা যায় না; তাকে কম priority বা একটি সীমিত বাজেট দিয়ে আলাদা রাখা হয়।

RTOS simulator-এ — একটি sporadic কাজ periodic task-কে হারায়

কোর্সের reference lab-এর rtos_sim.py সময়কে পূর্ণ tick-এ চালায়, প্রতি tick-এ একটি task (Spec decision 32: বড় priority সংখ্যা বেশি জরুরি, FreeRTOS-এর মতো; Cortex-M-এর interrupt priority-র উল্টো). Periodic task P: C = 2, T = D = 5. Sporadic কাজ S: tick 6-এ একবার আসে, C = 4, আর তাকে বেশি priority দেওয়া হলো, “ঘটনা জরুরি” ভেবে। আমার lab-এর scenario আর run:

{"scheduler": "fp", "ticks": 20,
 "tasks": [{"name": "P", "priority": 1, "period": 5, "wcet": 2},
           {"name": "S", "priority": 2, "release": 6, "script": [["compute", 4]]}]}
সত্যিকারের run — python -B rtos_sim.py run miss.json (reference lab, Python 3.13.5)
Gantt (# running, - ready, B blocked, . not active):
  0         1
  01234567890123456789
S ......####..........
P ##...#----###..##...

jobs:
  P released 0 start 0 finish 2 response 2 deadline 5 met
  P released 5 start 5 finish 11 response 6 deadline 10 MISSED
  P released 10 start 11 finish 13 response 3 deadline 15 met
  P released 15 start 15 finish 17 response 2 deadline 20 met
  S released 6 start 6 finish 10 response 4
CPU busy 12 of 20 ticks (60.0 %)
deadline misses: 1
Tick ধরে অবস্থা
সময় (tick)
CPU-তে
Gantt S
Gantt P
ফল
  1. প্রথম job স্বাভাবিক। P tick 0-এ release হয়, tick 0 আর 1 চলে, শেষ হয় 2-এ। Response 2, deadline 5: অনেক জায়গা বাকি।
  2. CPU অলস। Tick 2 থেকে 4 কেউ তৈরি নেই। এখানে utilisation-এর ছবি: 5 tick-এর মধ্যে 2 tick কাজ।
  3. দ্বিতীয় job এল, tick 5-এ। তার deadline 5 + 5 = 10. P tick 5 চালায়; আর মাত্র এক tick বাকি।
  4. S এল, tick 6-এ, বেশি priority নিয়ে। Simulator লেখে “S preempts P”. P-এর এক tick বাকি থাকতেই সে ready অবস্থায় অপেক্ষায় (Gantt-এ -).
  5. S টানা চার tick ধরে চলে। Tick 6 থেকে 9; S শেষ হয় 10-এ, response 4. S-এর কোনো deadline দেওয়া হয়নি, তাই তার দিক থেকে সব ঠিক।
  6. Deadline 10 এল, P শেষ হয়নি। Simulator লেখে DEADLINE MISS. Spec decision 34 অনুযায়ী দেরির job ফেলে দেওয়া হয় না, চলতে থাকে: tick 10-এ চলে, শেষ 11-এ, response 6 > 5. একই tick-এ job ৩ release হয়েছে, কিন্তু সে অপেক্ষার সারিতে (backlog).
  7. দেরির ঢেউ। Job ৩ শুরু করতে পারে 11-এ, শেষ 13-এ: response 3, deadline 15 রক্ষা। একটি miss পরের job-এর response-ও বাড়িয়েছে। Firm deadline হলে দেরির job ফেলে দেওয়াই ভালো হতো; সেই নীতি firmware-কে নিজে বেছে নিতে হয়।

এখন একই দুটি কাজ, শুধু priority উল্টো: P = 2, S = 1. আমার lab-এর meet.json-এর run-এ P-এর চারটি job-এর response 2, 2, 2, 2, সবাই রক্ষা, আর S শেষ হয় 13-এ, response 7. S-এর কোনো deadline নেই বলে এটি নিখুঁত সমাধান। এখান থেকে প্রথম শিক্ষা: “ঘটনা এসেছে, তাই জরুরি” ভাবনা ভুল priority দেয়। কোন নিয়মে priority দিলে সবচেয়ে ভালো, তা rate-monotonic নামে পর্ব ৫৬-এ আসবে।

৩ · Jitter আর drift — সময় কাঁপে, আর সময় সরে

একটি periodic কাজ ঠিক 1000 ms পরপর হওয়ার কথা। বাস্তবে দুই রকম বিচ্যুতি হয়, আর এদের সমাধান আলাদা। Jitter: প্রতিটি ঘটনা আদর্শ মুহূর্তের আশপাশে কাঁপে, কিন্তু গড়ে ঠিক থাকে। Drift: ভুল জমতে থাকে, প্রতি period-এ একটু, আর এক মাস পরে ঘড়ি অনেক পিছিয়ে।

Jitter-এর তিনটি উৎস: release-এর দেরি (tick-এর resolution, interrupt বন্ধ থাকা, অন্য কাজের বাধা), job-এর নিজের পথের পার্থক্য (কোনোবার alarm, কোনোবার telemetry), আর output-এর অপেক্ষা। Reference firmware coldroom.c-এর সত্যিকারের run-এ (README-র script) প্রতিটি t=N s লাইন বেরোনোর মুহূর্ত দেখা যায়। নিচের ব্লক সেই ২০টি timestamp থেকে jitter মাপে, আর দুই রকম অপেক্ষার নকশায় একদিনের drift হিসাব করে:

# cold room-এর সত্যিকারের board run: "t=N s" লাইন কখন বেরিয়েছে (ms)
out = [1000.0353, 2000.0352, 3000.0352, 4000.0352, 5000.0352,
       6000.0352, 7000.0352, 8000.0352, 9000.0353, 10000.0374,
       11000.0374, 12000.0374, 13000.0374, 14000.0374, 15000.0371,
       16000.0371, 17000.0371, 18000.0371, 19000.0371, 20000.0371]
late = [t - 1000 * (k + 1) for k, t in enumerate(out)]   # release থেকে দেরি
lo, hi = min(late), max(late)
print(f"release থেকে লাইন: {lo:.4f} .. {hi:.4f} ms")
print(f"output jitter = {hi - lo:.4f} ms = {(hi - lo) * 8000:.0f} cycle (8 MHz)")
gaps = [b - a for a, b in zip(out, out[1:])]
print(f"দুই লাইনের ব্যবধান: {min(gaps):.4f} .. {max(gaps):.4f} ms")

# দুই নকশা: (ক) next += 1000 (পরম সময়), (খ) কাজ শেষে আবার 1000 ms অপেক্ষা
def drift(c_ms, jobs):
    t_abs = t_rel = 0.0
    for _ in range(jobs):
        t_abs += 1000.0              # release শুধু ঘড়ির ওপর নির্ভর করে
        t_rel += 1000.0 + c_ms       # প্রতিবার কাজের সময় যোগ হয়
    return t_rel - t_abs

for name, c in (("board-এর মাপ", 325 / 8000), ("115200 baud-এ 17 অক্ষর", 17 * 10 / 115.2)):
    d = drift(c, 86400)
    print(f"{name:22}: C = {c:.4f} ms -> একদিনে (খ) পিছোয় {d / 1000:.1f} s, (ক) 0 s")

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

release থেকে লাইন: 0.0352 .. 0.0374 ms
output jitter = 0.0022 ms = 18 cycle (8 MHz)
দুই লাইনের ব্যবধান: 999.9997 .. 1000.0021 ms
board-এর মাপ          : C = 0.0406 ms -> একদিনে (খ) পিছোয় 3.5 s, (ক) 0 s
115200 baud-এ 17 অক্ষর: C = 1.4757 ms -> একদিনে (খ) পিছোয় 127.5 s, (ক) 0 s

Board-এ jitter প্রায় ১৮ cycle (board ms ছাপে চার দশমিকে, তাই ±১ cycle অনিশ্চিত). উৎস সহজ: t=10 থেকে সংখ্যাটি দুই অঙ্কের, তাই ছাপার পথ লম্বা; −0.50 আর +7.00-এর ছাপার পথও আলাদা। কিন্তু drift শূন্য: দুই লাইনের ব্যবধান কখনো 1000.0021 ms, কখনো 999.9997, আর বিশ সেকেন্ড পরেও লাইন 20000.04 ms-এ। কারণ coldroom.c লেখে next += SAMPLE_TICKS: পরের release আগের release থেকে গোনা, কাজ শেষ হওয়া থেকে নয়। উল্টো নকশা, “কাজ করা, তারপর 1000 ms ঘুমানো”, প্রতি period-এ কাজের সময়টুকু যোগ করে। Board-এ সেটি একদিনে 3.5 s; আসল chip-এ 115200 baud-এ লাইনটি পাঠানোর অপেক্ষা ধরলে প্রায় দুই মিনিট।

Board-এর সময় আসল chip-এর সময় নয়: বাজারঘর board একটি virtual Cortex-M3 (BG-M3), আসল কোনো পণ্য নয়। এতে প্রতিটি নির্দেশ ঠিক 1 cycle, exception-এ ঢোকা-ফেরা 0 cycle (Spec decision 17), আর UART তাৎক্ষণিক, baud rate-এর সময় গোনা হয় না (Spec decision 24). তাই এই পর্বের প্রতিটি cycle সংখ্যা “board-এর cycle”: চলা নির্দেশের সংখ্যা। আসল chip-এর সময় আসে datasheet, reference manual আর আসল chip-এ মাপ থেকে।

Drift-এর ক্ষতি ধীরে আসে বলে পরীক্ষায় ধরা পড়ে না। ১৯৯১ সালে উপসাগরীয় যুদ্ধে Dhahran-এ একটি Patriot ব্যবস্থা একটি Scud ঠেকাতে ব্যর্থ হয়; মার্কিন GAO-র ১৯৯২ সালের প্রতিবেদন (IMTEC-92-26) জানায়, ব্যবস্থাটি ১০০ ঘণ্টার বেশি একটানা চলছিল, আর সময়ের হিসাবের একটি সংখ্যাগত ভুল যত চলে তত বাড়ে। প্রচলিত বর্ণনায় ১০০ ঘণ্টায় ভুল প্রায় ০.৩৪ সেকেন্ড। ভুলটি প্রতি tick-এ ক্ষুদ্র, কিন্তু জমতে থাকা; ঠিক drift-এর চরিত্র। ভাবনার প্রশ্ন ২-এ এর বিস্তার।

৪ · WCET — মাপা বনাম হিসাব

সব হিসাবের ভিত্তি C, আর নিরাপদ হিসাবে লাগে WCET: একটি job-এর সবচেয়ে খারাপ সম্ভাব্য সময়, সব input আর সব hardware অবস্থার মধ্যে। সমস্যা হলো, এটি সরাসরি মাপা যায় না। যতবারই চালান, আপনি শুধু দেখা সর্বোচ্চটি পান, যার নাম high-water mark. সেটি WCET-এর নিচের সীমা মাত্র। WCET অনুমানের দুই প্রধান পথ:

মাপা (measurement-based)

Job-এর শুরু আর শেষে timestamp, অনেক input-এ চালানো, সর্বোচ্চ রাখা, তার ওপর একটি নিরাপত্তা margin. সরল, আসল hardware-এর সব প্রভাব ধরে; কিন্তু সবচেয়ে খারাপ পথ পরীক্ষায় না এলে অজানা থাকে। এর নাম measurement-based timing analysis.

হিসাব (static analysis)

Program না চালিয়ে compile করা কোডের সব পথ, loop-এর সর্বোচ্চ ঘোরা আর processor-এর মডেল (pipeline, cache, flash wait state) থেকে একটি নিরাপদ ওপরের সীমা। প্রমাণ দেয়, কিন্তু মডেল বানানো কঠিন আর সীমা প্রায়ই হতাশাজনকভাবে বড়। এর নাম static timing analysis.

Board-এ cold room-এর job মাপা

আমার lab-এ reference coldroom.c-এর একটি কপি (rtwcet.c), যার ১ s-এর প্রতিটি job চারটি অংশে মাপা হয়: I2C-ধাঁচের sensor পড়া (পর্ব ৫১), t=N s ছাপা, সীমা আর alarm-এর সিদ্ধান্ত, telemetry. Timestamp আসে SysTick থেকে: tick-এর সংখ্যা × 80000 যোগ চলতি tick-এ পার হওয়া count.

static uint32_t now_cyc(void)            /* board cycle, 10 ms tick */
{
    uint32_t t, v;
    do {                                  /* মাঝে tick এলে আবার পড়া */
        t = ticks;
        v = SysTick->VAL;
    } while (t != ticks);
    return t * 80000u + (79999u - v);
}
    /* main loop-এর ভেতরে, প্রতি 1 s-এর job: */
    uint32_t rel = next * 80000u;         /* এই job-এর release */
    uint32_t t0 = now_cyc();
    /* ... sensor পড়া → t1 ... ছাপা → t2 ... alarm → t3 ... */
    /* ... telemetry (প্রতি দশম job) → t4 */
    uint32_t c = t4 - t0;                 /* এই job-এর C */
    if (c > cmax) cmax = c;               /* high-water mark */
সত্যিকারের run — board.py run build/rtwcet.elf --script coldroom.json
(BG-M3, Clang 22.1.8 -O2; README-র script; ২০টির ৫টি লাইন দেখানো)
[  1000.1629 ms] UART:   job 1 -- start+10 C=325 (sense 25, print 232, logic+alarm 45, telemetry 23)
[  7000.1896 ms] UART:   job 7 A- start+10 C=523 (sense 25, print 232, logic+alarm 243, telemetry 23)
[ 10000.2371 ms] UART:   job 10 -T start+10 C=886 (sense 25, print 249, logic+alarm 44, telemetry 568)
[ 12000.1792 ms] UART:   job 12 A- start+10 C=424 (sense 25, print 249, logic+alarm 127, telemetry 23)
[ 20000.2363 ms] UART:   job 20 -T start+10 C=880 (sense 25, print 247, logic+alarm 39, telemetry 569)
[ 20000.2740 ms] UART: C min=318 max=886 cycles

পড়ার নিয়ম: A মানে এই job-এ alarm বদলেছে, T মানে telemetry গেছে; start+10 মানে release-এর ১০ cycle পরে job শুরু (SysTick ISR আর WFI থেকে জাগা). ফাঁকা অংশেও 23 cycle: সেটি মাপার নিজের খরচ, now_cyc()-এর ডাক আর n % 10-এর পরীক্ষা। এর নাম probe effect: মাপার যন্ত্র নিজেই সময় বদলায়। আসল project-এ এই খরচ আলাদা করে মেপে বাদ দেওয়া হয়, বা মাপার কোড পণ্যেও রেখে দেওয়া হয়, যাতে মাপা আর চালানো কোড একই থাকে।

README-র script-এ সর্বোচ্চ 886. কিন্তু এটি কি সবচেয়ে খারাপ পথ? Alarm বদল আর telemetry কখনো একই job-এ পড়েনি, আর তাপমাত্রা কখনো তিন অঙ্কের হয়নি। তাই একটি দ্বিতীয় script বানালাম (worst.json): 7.5 s-এ তাপমাত্রা 125.00 °C, যাতে তৃতীয় গরম reading পড়ে দশম job-এ, telemetry-র সঙ্গে:

সত্যিকারের run — board.py run build/rtwcet.elf --script worst.json
[ 10000.0446 ms] UART: t=10 s T=+125.00 C
[ 10000.0493 ms] GPIO PA6 ALARM ON
[ 10000.0739 ms] UART: ALARM ON: HIGH temperature
[ 10000.1494 ms] UART: TELEMETRY {"dev":"coldroom-1","seq":1,"temp_c":125.00,"alarm":"HIGH"}
[ 10000.2755 ms] UART:   job 10 AT start+10 C=1155 (sense 25, print 284, logic+alarm 243, telemetry 603)
[ 20000.2854 ms] UART: C min=325 max=1155 cycles
মাপ আর বাজেট
কোন job
sense · print · alarm · tel
C (cycle)
high-water mark
বাজেট
  1. সাধারণ job: 325 cycle. Sensor 25, ছাপা 232, সিদ্ধান্ত 45, ফাঁকা telemetry-র মাপার খরচ 23. 8 MHz-এ প্রায় 40.6 µs.
  2. Alarm বদলের job: 523. “ALARM ON: HIGH temperature” ছাপায় সিদ্ধান্তের অংশ 45 থেকে 243. নতুন পথ, নতুন সর্বোচ্চ।
  3. Telemetry-র job: 886. JSON লাইন ছাপায় 568 cycle. README-র script-এর পুরো run-এ এটাই সর্বোচ্চ; শুধু এটুকু দেখলে কেউ বলত “WCET 886”.
  4. অংশগুলো জোড়া: 1086. প্রতিটি অংশের নিজের সর্বোচ্চ যোগ করলে 25 + 249 + 243 + 569 = 1086: সেই পথগুলো একসাথে না দেখেও একটি বড় অনুমান। কিন্তু এটিও আসল সর্বোচ্চের নিচে, কারণ তিন অঙ্কের তাপমাত্রা কোনো পরীক্ষায় আসেনি।
  5. নতুন input, নতুন সর্বোচ্চ: 1155. 125.00 °C-এ ছাপা লম্বা (284), alarm আর telemetry একই job-এ। Input বদলাতেই high-water mark ৩০% বাড়ল। এটিও শেষ কথা নয়: n বছরের পর বছর বাড়লে দশ অঙ্ক পর্যন্ত ছাপা হবে।
  6. Margin যোগ। উদাহরণ হিসেবে 20%: 1155 × 1.2 = 1386 cycle = 173.2 µs. কত margin, তা কোনো সর্বজনীন সংখ্যা নয়; project আর প্রযোজ্য মানদণ্ড ঠিক করে, আর margin অজানা পথের বিরুদ্ধে প্রমাণ নয়, শুধু বীমা।
  7. আসল chip-এ ছবি বদলায়। Board-এ UART তাৎক্ষণিক। আসল chip-এ polled UART প্রতি অক্ষরে 10 বিট ÷ 115200 = 86.8 µs অপেক্ষা করে; এই job-এর 119 অক্ষর মানে 10.33 ms. সেখানে job-এর সময়ের প্রায় পুরোটাই UART-এর অপেক্ষা, নির্দেশ নয়।

একই বিশ্লেষণ Python-এ, দুই run-এর সব ৪০টি job নিয়ে:

# cold room-এর ১ s-এর job: board-এ মাপা cycle (rtwcet.elf, দুই script)
# প্রতিটি job: (মোট C, sense, print, logic+alarm, telemetry)
readme = [(325, 25, 232, 45, 23)] * 2 + [(326, 25, 232, 46, 23)] * 2 + [
    (325, 25, 232, 45, 23)] * 2 + [(523, 25, 232, 243, 23), (318, 25, 232, 38, 23),
    (323, 25, 232, 43, 23), (886, 25, 249, 44, 568), (341, 25, 249, 44, 23),
    (424, 25, 249, 127, 23), (343, 25, 249, 46, 23), (343, 25, 249, 46, 23),
    (339, 25, 247, 44, 23), (339, 25, 247, 44, 23), (533, 25, 247, 238, 23),
    (334, 25, 247, 39, 23), (334, 25, 247, 39, 23), (880, 25, 247, 39, 569)]
worst = [(325, 25, 232, 45, 23)] * 2 + [(326, 25, 232, 46, 23)] * 5 + [
    (360, 25, 267, 45, 23)] * 2 + [(1155, 25, 284, 243, 603)] + [
    (370, 25, 284, 38, 23)] * 9 + [(950, 25, 284, 38, 603)]
for j in readme + worst:
    assert j[0] == sum(j[1:]), j          # অংশের যোগফল = মোট

def report(name, jobs):
    c = sorted(j[0] for j in jobs)
    comp = sum(max(j[k] for j in jobs) for k in range(1, 5))
    print(f"{name}: {len(c)} job, C = {c[0]}..{c[-1]} cycle, "
          f"মাঝের মান {c[len(c) // 2]}, অংশের সর্বোচ্চ যোগ = {comp}")
    return c[-1], comp

m1, comp1 = report("README script", readme)
m2, comp2 = report("worst script ", worst)
hwm = max(m1, m2)                         # সব পরীক্ষায় দেখা সর্বোচ্চ
for margin in (0.0, 0.2, 0.5):
    budget = round(hwm * (1 + margin))
    print(f"margin {margin:>4.0%}: বাজেট {budget:5} cycle = {budget / 8:6.1f} us")
print(f"README run একা থাকলে মাপা {m1}, অংশ জুড়ে {comp1}: দুটিই {hwm}-এর নিচে")

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

README script: 20 job, C = 318..886 cycle, মাঝের মান 339, অংশের সর্বোচ্চ যোগ = 1086
worst script : 20 job, C = 325..1155 cycle, মাঝের মান 370, অংশের সর্বোচ্চ যোগ = 1155
margin   0%: বাজেট  1155 cycle =  144.4 us
margin  20%: বাজেট  1386 cycle =  173.2 us
margin  50%: বাজেট  1732 cycle =  216.5 us
README run একা থাকলে মাপা 886, অংশ জুড়ে 1086: দুটিই 1155-এর নিচে

মাঝের মান (339 বা 370) আর সর্বোচ্চের ফারাক প্রায় তিনগুণ। গড় দেখে বাজেট করলে প্রতি দশম job বাজেট ভাঙত। লক্ষ্য করুন, assert প্রতিটি সারির অংশগুলোর যোগফল মোটের সঙ্গে মিলিয়ে নিয়েছে: board-এর লাইন থেকে সংখ্যা তোলায় ভুল হয়নি। মূল শিক্ষা: মাপা WCET পরীক্ষার input-এর মতোই ভালো। প্রতিটি শাখা, প্রতিটি loop-এর সর্বোচ্চ ঘোরা (এখানে ছাপার অঙ্কসংখ্যা) ইচ্ছা করে চালাতে হয়।

হিসাবের পথ — কেন কঠিন

Static analysis-এর ধারণা সরল: control-flow graph-এর প্রতিটি basic block-এর সর্বোচ্চ cycle, প্রতিটি loop-এর সর্বোচ্চ ঘোরা, তারপর দীর্ঘতম পথ। এই board-এ এটি প্রায় খেলা, কারণ এক নির্দেশ = এক cycle; যেমন cold room-এর SysTick ISR Clang-এর -S output-এ ঠিক ছয়টি নির্দেশ (movw, movt, ldr, adds, str, bx lr), তাই board-এ 6 cycle. আসল chip-এ তিনটি জিনিস হিসাব কঠিন করে। এক, pipeline: একই নির্দেশ আগে-পরের নির্দেশ অনুযায়ী আলাদা সময় নেয়, আর branch নিলে pipeline ভরতে বাড়তি cycle. দুই, flash-এর wait state: দ্রুত clock-এ flash তাল রাখতে পারে না, তাই chip prefetch buffer বা ছোট cache রাখে; যেমন STM32F1 পরিবারের reference manual 72 MHz-এ flash-এ ২টি wait state বলে। তিন, cache (Computer Architecture পর্ব ৪৫): একই loop প্রথমবার ধীর, পরে দ্রুত। এই কারণে বড় processor-এ সঠিক static analysis একটি বিশেষজ্ঞ কাজ; ছোট Cortex-M0/M3-এ cache না থাকলে তুলনায় সহজ।

৫ · Latency budget — ঘটনা থেকে সাড়া পর্যন্ত

একটি একক job-এর R ছাড়াও ব্যবহারকারী দেখেন পুরো পথের দেরি: তাপমাত্রা সীমা পেরোল, আর কখন alarm বাজল? এই end-to-end latency-কে ধাপে ভাগ করে প্রতিটি ধাপের সর্বোচ্চ লেখার নাম latency budget. ISR-এর স্তরে একই হিসাব (interrupt latency, response-time analysis) পর্ব ৪৩-এ হয়েছে; এখানে আমরা সেকেন্ডের স্তরে, পুরো যন্ত্রের নকশায়।

Cold room-এর নকশা README থেকে স্থির: reading প্রতি 1 s, পরপর ৩টি সীমার বাইরের reading-এ alarm চালু, 0.50 °C-এর hysteresis. ধাপগুলো:

  1. Phase: তাপমাত্রা দুই reading-এর মাঝে যেকোনো সময় পেরোতে পারে। পরের reading পর্যন্ত অপেক্ষা: 0 থেকে প্রায় 1 s.
  2. নিশ্চিত করা: প্রথম গরম reading-এর পরে আরও দুটি, 2 s. এটি ইচ্ছাকৃত দেরি: দরজা খুলে একবার গরম বাতাস ঢুকলে মিথ্যা alarm যেন না বাজে।
  3. Job-এর response: release থেকে alarm-এর লাইন: board-এ 0.0634 ms.
  4. বাকি পথ: MQTT-তে খবর, network, dashboard. এগুলো মডিউল ১২-এর বিষয়; এখানে সংখ্যা নেই, তাই বাজেটে “মাপা হয়নি” লিখে আলাদা রাখা।

ছবি ৫৪.১ — একই 8.25 °C, দুই মুহূর্তে: alarm-এর দেরি 2 s বনাম 3 s

Board-এর সত্যিকারের run, reference coldroom.c; প্রতিটি দাগ একটি 1 s-এর reading

Cold room-এর alarm-এর দেরি, পেরোনোর মুহূর্ত অনুযায়ী ক) পেরোল 3999 ms-এ খ) পেরোল 4001 ms-এ 02468 s 02468 s 8.25 °C 123 ALARM 6000.06 দেরি 2001.06 ms: প্রায় সেরা অবস্থা 8.25 °C 123 দেরি 2999.06 ms: প্রায় সবচেয়ে খারাপ; 4 s-এর reading (ধূসর) পুরোনো মান দেখে
ছবি ৫৪.১ — লাল ড্যাশ দাগে তাপমাত্রা পেরোয়, হলুদ বৃত্ত গরম reading-এর গোনা, লাল বৃত্তে তৃতীয়টি আর alarm. মাত্র ২ ms-এর পার্থক্যে alarm পুরো এক সেকেন্ড আগে-পরে।
সত্যিকারের run — board.py run build/coldroom.elf --script phase_early.json  (পেরোল 3999 ms)
[  3999.0000 ms] > cold-room temperature: +8.25 C
[  4000.0352 ms] UART: t=4 s T=+8.25 C
[  6000.0634 ms] UART: ALARM ON: HIGH temperature
সত্যিকারের run — ... --script phase_late.json  (পেরোল 4001 ms)
[  4000.0352 ms] UART: t=4 s T=+4.00 C
[  4001.0000 ms] > cold-room temperature: +8.25 C
[  7000.0634 ms] UART: ALARM ON: HIGH temperature

দুটি run একটি সাধারণ সূত্রের দুই প্রান্ত: alarm-এর দেরি = (CONFIRM − 1) × PERIOD + phase + R. নিচের মডেল এক period-এর সব phase ১ ms ধাপে চালিয়ে সীমা বের করে, আর board-এর তিনটি run-এর সঙ্গে মেলায় (README-র script-এ পেরোনো 4500 ms-এ):

# তাপমাত্রা সীমা পেরোনো থেকে ALARM ON পর্যন্ত: reading প্রতি 1 s, পরপর 3টি লাগে
PERIOD, CONFIRM = 1000, 3        # ms, README-র নকশা
R_JOB = 0.0634                   # release থেকে "ALARM ON" লাইন (board run, ms)

def alarm_time(cross_ms):
    """cross_ms-এ 8.25 °C হলো; কোন reading-এ তৃতীয় গরম পড়া?"""
    k, seen = 1, 0
    while True:
        t = k * PERIOD           # k-তম reading-এর release
        if t > cross_ms:         # এই reading নতুন তাপমাত্রা দেখে
            seen += 1
            if seen == CONFIRM:
                return t + R_JOB
        k += 1

lat = []
for k in range(1000):                    # এক period-এর সব phase, 1 ms ধাপে
    cross = 3000.5 + k                   # reading-এর মুহূর্তে ঠিক পড়ে না
    lat.append((alarm_time(cross) - cross, cross))
best, worst = min(lat), max(lat)
print(f"সেরা  : {best[0]:9.4f} ms (পেরোল {best[1]:.1f} ms-এ)")
print(f"সবচেয়ে খারাপ: {worst[0]:9.4f} ms (পেরোল {worst[1]:.1f} ms-এ)")
for cross in (3999, 4001, 4500):          # board-এ চালানো তিনটি script
    print(f"পেরোল {cross} ms -> ALARM {alarm_time(cross):.4f} ms, "
          f"দেরি {alarm_time(cross) - cross:.4f} ms")
print(f"সূত্র: (CONFIRM - 1) x PERIOD + phase + R = {CONFIRM - 1} s .. {CONFIRM} s + R")

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

সেরা  : 2000.5634 ms (পেরোল 3999.5 ms-এ)
সবচেয়ে খারাপ: 2999.5634 ms (পেরোল 3000.5 ms-এ)
পেরোল 3999 ms -> ALARM 6000.0634 ms, দেরি 2001.0634 ms
পেরোল 4001 ms -> ALARM 7000.0634 ms, দেরি 2999.0634 ms
পেরোল 4500 ms -> ALARM 7000.0634 ms, দেরি 2500.0634 ms
সূত্র: (CONFIRM - 1) x PERIOD + phase + R = 2 s .. 3 s + R

সীমা তাই 2 s থেকে 3 s, সঙ্গে R. মডেলের তিনটি সময় board-এর তিনটি run-এর সঙ্গে চার দশমিক পর্যন্ত মেলে (6000.0634, 7000.0634, আর README-র 7000.0634). তাই এখন একটি প্রতিশ্রুতি লেখা যায়: “সীমা পেরোনোর 3 s + job-এর response-এর মধ্যে PA6 উঁচু হবে।” লক্ষ্য করুন, বাজেটের প্রায় পুরোটা ইচ্ছাকৃত নকশা (sampling আর নিশ্চিত করা), CPU-র কাজ মাত্র 0.06 ms. দ্রুত CPU এখানে কিছুই বদলায় না; বদলায় period আর CONFIRM. পরীক্ষার input-এ phase-এর দুই প্রান্ত রাখা কেন জরুরি, ছবিটিই দেখায়।

ধাপসর্বোচ্চউৎস
Phase: পরের reading পর্যন্ত< 1 sREADME-র নকশা, period 1 s
আরও দুটি reading-এ নিশ্চিত করা2 sREADME-র নকশা, CONFIRM 3
Job-এর response (release → PA6)0.0634 ms (board)board-এর run; আসল chip-এ UART-এর অপেক্ষাসহ কয়েক ms
MQTT → dashboardমাপা হয়নিপর্ব ৭৩-এ broker আর QoS

৬ · Utilisation — CPU-র কতটা ভরা

প্রতিটি periodic বা sporadic task CPU-র সময়ের একটি অংশ চায়: C/T. সবার যোগফল utilisation, U = Σ Ci/Ti. U = 0.25 মানে গড়ে প্রতি চার ভাগ সময়ের এক ভাগ CPU ব্যস্ত। প্রথম নিয়মটি স্পষ্ট: এক CPU-তে U > 1 হলে কোনো scheduler দিয়েই সব deadline রাখা যায় না, কারণ কাজ সময়ের চেয়ে বেশি। কিন্তু উল্টোটা সত্য নয়: U ≤ 1 হলেও deadline হারাতে পারে, যেমন অংশ ২-এর P আর S.

যোগফল
যোগ হলো
C/T
মোট U
রায়
  1. SysTick ISR. ছয়টি নির্দেশ প্রতি 10 ms-এ: 6 ÷ 80000 = 0.000075. আসল Cortex-M3-এ প্রবেশ-ফেরার কয়েক ডজন cycle যোগ হতো (board-এ 0, Spec decision 17), তাতেও ক্ষুদ্র।
  2. 1 s-এর job, board-এর মাপে। সবচেয়ে খারাপ মাপা 1155 cycle = 144.4 µs প্রতি 1000 ms: 0.000144. মোট 0.0219%: cold room-এর MCU ৯৯.৯৮% সময় ঘুমিয়ে, যা low-power নকশার (পর্ব ৬০) জন্য সুখবর।
  3. একই job, আসল chip-এর polled UART-সহ। 119 অক্ষর × 86.8 µs যোগ হয়ে C = 10474.2 µs; মোট U প্রায় 1.05%. সংখ্যা পঞ্চাশ গুণ বেড়েছে, তবু ছোট। শিক্ষা: board-এর cycle দিয়ে U হিসাব করলে peripheral-এর অপেক্ষা হারিয়ে যায়।
  4. অংশ ২-এর task P. C = 2, T = 5: U = 0.4.
  5. S যোগ হলো, sporadic হিসেবে। ন্যূনতম ব্যবধান 10 ধরে C/T = 4/10 = 0.4; মোট 0.8 ≤ 1. দরকারি শর্ত পূরণ, তবু অংশ ২-এ P একটি deadline হারিয়েছে।
  6. U একা যথেষ্ট নয়। rtos_sim.py analyze: S উঁচু priority হলে R(P) > 5, MISS; ছোট period-কে উঁচু priority দিলে (rate-monotonic) R(P) = 2, R(S) = 8, দুটিই রক্ষা। একই U, ভিন্ন ফল: পরীক্ষাটি priority-র ক্রমের ওপর, যার পুরো তত্ত্ব পর্ব ৫৬-এ।
# Utilisation U = Σ C/T. cold room-এর MCU, 8 MHz; C board-এ মাপা (cycle)
F = 8_000_000                             # cycle প্রতি সেকেন্ডে
CHAR_US = 10 / 115200 * 1e6               # 8N1: এক অক্ষরে 10 বিট = 86.8 us

def show(title, tasks):
    print(title)
    u = 0.0
    for name, c_us, t_ms in tasks:
        ui = c_us / (t_ms * 1000)
        u += ui
        print(f"  {name:13} C={c_us:9.1f} us  T={t_ms:6} ms  C/T={ui:.6f}")
    print(f"  মোট U = {u:.6f} = {u:.4%}")

# ১) board-এর মাপ: UART তাৎক্ষণিক (Spec decision 24)
show("ক) virtual board-এর cycle", [
    ("SysTick ISR", 6 / F * 1e6, 10),             # ছয় নির্দেশ, প্রবেশ-ফেরা 0
    ("1 s-এর job", 1155 / F * 1e6, 1000)])        # সবচেয়ে খারাপ মাপা job

# ২) আসল chip-এ polled UART: প্রতিটি অক্ষরে অপেক্ষা
lines = ["t=10 s T=+125.00 C\r\n", "ALARM ON: HIGH temperature\r\n",
         '{"dev":"coldroom-1","seq":1,"temp_c":125.00,"alarm":"HIGH"}\r\n']
chars = len(lines[0]) + len(lines[1]) + len("TELEMETRY ") + len(lines[2])
print(f"সবচেয়ে খারাপ job-এ UART-এ {chars} অক্ষর = {chars * CHAR_US / 1000:.2f} ms")
show("খ) একই job, 115200 baud-এ অপেক্ষাসহ", [
    ("SysTick ISR", 6 / F * 1e6, 10),
    ("1 s-এর job", 1155 / F * 1e6 + chars * CHAR_US, 1000)])

# ৩) P আর S: U কম হলেও deadline হারাতে পারে (1 tick = 1 ms ধরে)
show("গ) P (C=2, T=5) আর S (C=4, ন্যূনতম ব্যবধান 10)", [
    ("P", 2000, 5), ("S", 4000, 10)])

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

ক) virtual board-এর cycle
  SysTick ISR   C=      0.8 us  T=    10 ms  C/T=0.000075
  1 s-এর job    C=    144.4 us  T=  1000 ms  C/T=0.000144
  মোট U = 0.000219 = 0.0219%
সবচেয়ে খারাপ job-এ UART-এ 119 অক্ষর = 10.33 ms
খ) একই job, 115200 baud-এ অপেক্ষাসহ
  SysTick ISR   C=      0.8 us  T=    10 ms  C/T=0.000075
  1 s-এর job    C=  10474.2 us  T=  1000 ms  C/T=0.010474
  মোট U = 0.010549 = 1.0549%
গ) P (C=2, T=5) আর S (C=4, ন্যূনতম ব্যবধান 10)
  P             C=   2000.0 us  T=     5 ms  C/T=0.400000
  S             C=   4000.0 us  T=    10 ms  C/T=0.400000
  মোট U = 0.800000 = 80.0000%

খ-এর ফল আরেকটি নকশার প্রশ্ন তোলে: CPU ১০ ms একটি UART-এর flag-এর জন্য polling করে বসে থাকে। Cold room-এ ক্ষতি নেই, কিন্তু একই MCU-তে কোনো 5 ms-এর deadline থাকলে সেই কাজ এই অপেক্ষার পেছনে আটকে যেত। প্রতিকার পর্ব ৪৬-এর DMA বা interrupt-চালিত ring buffer (পর্ব ৪৯).

গ-এর জন্য reference lab-এর বিশ্লেষণ, S-কে ন্যূনতম ব্যবধান 10-এর periodic task ধরে আর rate-monotonic ক্রমে:

সত্যিকারের run — python -B rtos_sim.py analyze spor_rm.json
tasks (highest priority first): P(C=2,T=5), S(C=4,T=10)
U = 2/5 + 4/10 = 0.8000
Liu-Layland bound n(2^(1/n)-1) for n=2: 0.8284
U <= bound: schedulable under RM (sufficient test)
  R(P) = 2  (deadline 5) OK
  R(S) = 8  (deadline 10) OK
hyperperiod = 10 ticks
সত্যিকারের run — ... analyze spor_given.json  (S-কে উঁচু priority দেওয়া)
  R(S) = 4  (deadline 10) OK
  R(P) = > 5  (deadline 5) MISS

দ্বিতীয় run-এর বাকি লাইন দেখানো হয়নি; সেখানে tool-টি একই U আর Liu–Layland bound-এর লাইন ছাপে, যা শুধু rate-monotonic ক্রমের জন্য প্রযোজ্য, এই দেওয়া ক্রমের জন্য নয়। এই সীমা আর response-time analysis-এর পুরো ব্যাখ্যা OS-এর দৃষ্টিতে আছে Operating Systems পর্ব ২০-এ, আর RTOS-এর task-এ পর্ব ৫৬-এ।

আরও গভীরে: WCET গবেষণা নিজেই একটি ক্ষেত্র; Wilhelm ও সহলেখকদের ২০০৮ সালের সমীক্ষা (ACM Transactions on Embedded Computing Systems) মাপা আর static, দুই পথের tool-এর তুলনা করে। Static পথে abstract interpretation দিয়ে cache আর pipeline-এর সম্ভাব্য সব অবস্থা একসাথে মডেল করা হয়। জটিল processor-এ একটি অদ্ভুত ঘটনা আছে, timing anomaly: একটি cache miss-এর কারণে মোট সময় কমে যেতে পারে, তাই “প্রতিটি অংশের সবচেয়ে খারাপ জুড়লেই সবচেয়ে খারাপ” নিয়মটি সেখানে নিরাপদ নয়। এই board-এ এক নির্দেশ এক cycle বলে অংশ জোড়া নিরাপদ; আসল chip-এ নয়।

পরীক্ষা ও ইন্টারভিউতে: “Hard আর soft real-time-এর পার্থক্য?” → deadline পেরোলে ব্যর্থতা বনাম মান কমা; শ্রেণি পরিণাম দিয়ে, গতি দিয়ে নয়। “WCET কেন শুধু মেপে পাওয়া যায় না?” → মাপা সর্বোচ্চ সব পথ আর অবস্থা ঢাকে না; তা নিচের সীমা। “Sporadic আর aperiodic-এর পার্থক্য?” → sporadic-এর ন্যূনতম আগমন-ব্যবধান জানা, তাই হিসাবযোগ্য। “U = 0.8, সব deadline কি রক্ষা?” → নিশ্চিত নয়; priority-র ক্রম আর response-time analysis লাগে। “Super loop-এ period-এর drift কীভাবে এড়াবেন?” → পরের release আগের release থেকে গুনে (next += T), কাজ শেষ থেকে নয়।

৭ · AI-এর যুগে real-time নকশা যাচাই

AI assistant-কে “আমার task-গুলো কি সময়মতো চলবে?” জিজ্ঞেস করলে প্রায়ই আত্মবিশ্বাসী উত্তর আসে, যার সংখ্যার কোনো উৎস নেই। সাধারণ ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
Real-time মানে “দ্রুত” ধরে নেয়, আর দ্রুত chip সুপারিশ করেDeadline আর তার পরিণাম লিখুন; cold room-এর মতো অনেক বাজেটে CPU-র অংশ নগণ্য
গড় বা একটি run-এর সময়কে WCET বলেInput-এর প্রতিটি শাখা আর সীমা চালিয়ে high-water mark; সঙ্গে margin বা static সীমা
Cortex-M-এর cycle সংখ্যা উৎস ছাড়া দেয়, flash wait state ভুলে যায়Chip-এর reference manual আর ARM-এর TRM; আসল chip-এ timer দিয়ে মাপা
“U ≤ 1, তাই নিরাপদ” বলে, priority-র ক্রম না দেখেSimulator-এ চালানো আর response-time analysis (পর্ব ৫৬)
delay_ms(1000) দিয়ে period বানায়Drift-এর হিসাব; পরম release (next += T)
Polled printf/UART-এর অপেক্ষা সময়ের হিসাবে রাখে নাঅক্ষর × (10 ÷ baud) যোগ করা; DMA বা ring buffer

প্রসঙ্গ আর যাচাইয়ের শর্ত শুরুতেই দিন:

আমি একটি Cortex-M3 (8 MHz, RTOS নেই) firmware-এ একটি ঠান্ডা ঘরের monitor বানাচ্ছি: তাপমাত্রা প্রতি 1 s, পরপর 3টি সীমার বাইরের reading-এ alarm, প্রতি 10 s-এ 115200 baud UART-এ একটি telemetry লাইন। ১. প্রতিটি কাজের deadline আর তা hard, firm না soft, কারণসহ লেখো। ২. সীমা পেরোনো থেকে alarm পর্যন্ত সবচেয়ে খারাপ দেরির সূত্র দাও, ধাপে ধাপে। ৩. একটি job-এর execution time মাপার C কোড দাও SysTick দিয়ে, আর বলো কোন input-এ সবচেয়ে খারাপ পথ চলবে। ৪. Polled UART-এর অপেক্ষা utilisation-এ কত যোগ করে, হিসাব দেখাও। ৫. কোনো cycle সংখ্যা বা register-এর নাম দিলে উৎস বলো; নিশ্চিত না হলে সেটি স্পষ্ট করে বলো।

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

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

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

প্র ০১“Hard real-time” শব্দটি প্রায়ই “খুব দ্রুত” অর্থে ব্যবহার হয়। একটি ঠান্ডা ঘরের alarm, যার deadline সেকেন্ডে, কি hard real-time হতে পারে? আর একটি মাইক্রোসেকেন্ডের কাজ কি soft হতে পারে?

পারে, দুটিই। শ্রেণির সংজ্ঞা দাঁড়িয়ে আছে deadline পেরোনোর পরিণামের ওপর, সময়ের মাপের ওপর নয়। Real-time তত্ত্বের পরিচিত পাঠ্যবইগুলোতে (যেমন Hermann Kopetz-এর বই) hard deadline বলা হয় সেটিকে, যা পেরোলে বিপর্যয়কর ফল হতে পারে; soft-এ দেরির ফল তবু কাজে লাগে। এখানে “তাড়াতাড়ি” শব্দটি কোথাও নেই।

বাজারঘরের cold room ধরুন। নকশা প্রতিশ্রুতি দেয়: সীমা পেরোনোর 3 s আর job-এর response-এর মধ্যে alarm. ধরুন কোনো bug-এ alarm-এর কাজটি কখনো দশ মিনিট আটকে থাকে। কম্প্রেসর বন্ধ থাকলে সেই দশ মিনিটে তাপমাত্রা বাড়তে থাকে, আর রাতে কেউ খেয়াল না করলে সকালের মধ্যে মাছ-মাংস নষ্ট। পরিণাম অপূরণীয় আর আর্থিকভাবে বড়, তাই মালিকের দৃষ্টিতে “alarm একটি নির্দিষ্ট সময়ের মধ্যে বাজবেই” একটি hard প্রয়োজন, যদিও সময়টি সেকেন্ড বা মিনিটের। অন্যদিকে প্রতিটি 1 s-এর reading-কে firm বলা যায়: একটি দেরিতে এলে ফেলে দেওয়া যায়, পরেরটি আসছে।

উল্টো উদাহরণ: একটি অডিও DAC-এ প্রতি 22.7 µs-এ (44.1 kHz) একটি sample দিতে হয়। একটি দেরি হলে একটি ছোট ক্লিক শোনা যায়; বিরক্তিকর, কিন্তু কেউ আহত হয় না। Deadline মাইক্রোসেকেন্ডের, অথচ শ্রেণি soft. বাস্তবে এই দুই মাত্রা মেলে না বলেই নকশাকারকে আলাদা করে দুটি প্রশ্ন করতে হয়: কত দ্রুত, আর কতটা জরুরি? প্রথমটি ঠিক করে কোন hardware আর কোন priority; দ্বিতীয়টি ঠিক করে কতটা প্রমাণ দরকার: মাপা সর্বোচ্চে margin যথেষ্ট, নাকি static analysis আর স্বাধীন পর্যালোচনা।

আরেকটি সূক্ষ্মতা: “hard” প্রায়ই পুরো system-এর বৈশিষ্ট্য হিসেবে বলা হয়, কিন্তু একটি যন্ত্রে নানা শ্রেণির deadline পাশাপাশি থাকে। Cold room-এ alarm hard, reading firm, আর telemetry soft শ্রেণির। ভালো নকশা প্রতিটির জন্য আলাদা নীতি নেয়, যেমন telemetry দেরিতে গেলে ক্ষতি নেই, কিন্তু alarm-এর পথে কোনো blocking কাজ রাখা চলবে না।

মূল উপলব্ধি: শ্রেণি আসে পরিণাম থেকে, দ্রুততা থেকে নয়। একটি যন্ত্রের প্রতিটি deadline-কে আলাদা করে শ্রেণিবদ্ধ করলে বোঝা যায় কোথায় কঠোর প্রমাণ লাগবে আর কোথায় সরল নকশাই যথেষ্ট।

প্র ০২১৯৯১ সালের Dhahran-এর Patriot ব্যর্থতাকে প্রায়ই “ক্ষুদ্র সংখ্যাগত ভুল” বলা হয়। Real-time নকশার দৃষ্টিতে এখানে আসল শিক্ষা কী, আর একটি ছোট firmware-এ একই ধরনের ফাঁদ কোথায় লুকায়?

মার্কিন GAO-র ফেব্রুয়ারি ১৯৯২-এর প্রতিবেদন (IMTEC-92-26) অনুযায়ী Dhahran-এর Patriot ব্যাটারি একটি Scud-কে track করতে আর ঠেকাতে ব্যর্থ হয়, কারণ weapons control computer-এর software-এ সময়ের হিসাবের একটি ভুল ছিল, যার প্রভাব যত বেশি সময় ব্যবস্থাটি একটানা চলে তত বাড়ে। ব্যাটারিটি তখন ১০০ ঘণ্টার বেশি চলছিল। প্রচলিত বিশ্লেষণে বলা হয়, সময় রাখা হতো দশমাংশ সেকেন্ডের গণনায়, আর 0.1 binary-তে ঠিকভাবে লেখা যায় না বলে প্রতিটি গুণে একটি ক্ষুদ্র ভুল ঢুকত; ১০০ ঘণ্টায় তা প্রায় ০.৩৪ সেকেন্ডে দাঁড়ায়, যা দ্রুতগামী লক্ষ্যের ক্ষেত্রে বড় দূরত্ব। প্রতিবেদন আরও বলে, সমস্যা আগে জানা ছিল আর সংশোধিত software Dhahran-এ পৌঁছেছিল ঘটনার পরের দিন। বিস্তারিত সংখ্যাগুলো প্রতিবেদনের মূল কপিতে মিলিয়ে নেওয়াই ভালো।

Real-time-এর দৃষ্টিতে আসল শিক্ষা তিনটি। এক, এটি jitter নয়, drift: প্রতিটি tick-এর ভুল এত ছোট যে কোনো একক পরীক্ষায় ধরা পড়ে না; ক্ষতি আসে জমে। দুই, পরীক্ষার পরিস্থিতি মাঠের পরিস্থিতি নয়: ঘণ্টার পর ঘণ্টা একটানা চালানো কারও পরীক্ষার তালিকায় ছিল না। তিন, “system চলার সময়” নিজেই একটি input, যা WCET-এর মতো সময়ের আচরণও বদলায়।

ছোট firmware-এ একই ফাঁদ বেশ কয়েক রূপে আসে। এই পর্বের অংশ ৩: “কাজ করা, তারপর 1000 ms ঘুমানো” লিখলে প্রতি period-এ কাজের সময় যোগ হয়; আসল UART-এর অপেক্ষা ধরলে একদিনে প্রায় দুই মিনিট। একটি ৩২ বিটের ms counter ২৩২ ms, প্রায় ৪৯.৭ দিনে wrap করে; wrap-safe বিয়োগ না লিখলে সেদিন সব timeout ভেঙে যায় (পর্ব ৪৪). Float-এ সময় জমালে সংখ্যা বড় হতে হতে ছোট যোগ হারিয়ে যায়। আর এই পর্বের WCET-এর মাপে: sample counter n বাড়তে থাকায় ছাপার পথ বছরের পর বছর লম্বা হয়।

প্রতিকারের নিয়মগুলো সরল: সময়ের মূল একক integer-এ রাখা (tick বা µs), পরের release আগের release থেকে গোনা, wrap-এর বিয়োগ unsigned-এ, আর “অনেক দিন চালানো”-কে পরীক্ষার অংশ করা, যা simulator-এ সময় এগিয়ে দিয়ে সহজেই করা যায়।

মূল উপলব্ধি: ধীরে জমা সময়ের ভুল কোনো ছোট পরীক্ষায় ধরা পড়ে না। Integer সময়, পরম release আর দীর্ঘ চালানোর পরীক্ষা: এই তিন অভ্যাস drift-এর বিরুদ্ধে প্রধান রক্ষা।

প্র ০৩এই পর্বে board-এ মাপা সর্বোচ্চ 886 থেকে নতুন input-এ 1155 cycle হলো। তাহলে মাপা পথের ওপর কতটা ভরসা করা যায়, আর শিল্পে মাপা আর static analysis কীভাবে একসাথে ব্যবহার হয়?

মাপা পথের সবচেয়ে বড় গুণ হলো এটি আসল hardware-এর সব প্রভাব নিজে থেকে ধরে: pipeline, flash wait state, bus-এর প্রতিযোগিতা, এমনকি datasheet-এ না লেখা আচরণ। সবচেয়ে বড় দুর্বলতা হলো এটি শুধু চালানো পথ দেখে। এই পর্বে README-র script একটি যুক্তিসংগত পরীক্ষা ছিল, তবু দুটি জিনিস বাদ পড়েছিল: alarm বদল আর telemetry একই job-এ, আর তিন অঙ্কের তাপমাত্রা। দুটি যোগ হতেই সর্বোচ্চ ৩০% বাড়ল। কেউ 886-এর ওপর 20% margin দিলে বাজেট হতো প্রায় 1063, যা 1155-এর নিচে। Margin কাজ করেনি, কারণ ফাঁকটি ছিল input-এ, মাপে নয়।

এর প্রতিকার দুই দিক থেকে। Input-এর দিক থেকে: coverage-চালিত পরীক্ষা, যেখানে প্রতিটি শাখা আর প্রতিটি loop-এর সর্বোচ্চ ঘোরা ইচ্ছা করে চালানো হয়; এখানে যেমন uart_put_u32-এর অঙ্কসংখ্যা। কোড দেখেই বলা যায়, ৩২ বিটের সংখ্যায় সর্বোচ্চ দশ অঙ্ক; এটি static যুক্তি, পরীক্ষা শুধু তা চালিয়ে দেখে। Hardware-এর দিক থেকে: cache থাকলে প্রতিবার আগে cache খালি করে মাপা, interrupt-এর সবচেয়ে খারাপ ভিড় তৈরি করা।

Static analysis-এর দিকে, গবেষণা আর শিল্পে abstract interpretation-ভিত্তিক tool আছে, যেগুলো compile করা binary পড়ে processor-এর মডেল দিয়ে নিরাপদ ওপরের সীমা দেয়। Wilhelm ও সহলেখকদের ২০০৮ সালের সমীক্ষা এমন বেশ কিছু tool আর পদ্ধতির তুলনা করে। এদের সীমা নিরাপদ, কিন্তু মডেল যত সরল, সীমা তত ফোলা; আর প্রতিটি নতুন processor-এর মডেল বানানো বড় কাজ। মাঝের পথও আছে, hybrid: ছোট অংশগুলো (basic block) মেপে, পথের কাঠামো static-ভাবে জুড়ে সীমা। এই পর্বের “অংশের সর্বোচ্চ যোগ” সেই ধারণার সরল রূপ, যা এই board-এ নিরাপদ কারণ এক নির্দেশ এক cycle; জটিল processor-এ timing anomaly এই যোগকে অনিরাপদ করতে পারে।

বিমান বা গাড়ির মতো safety-critical ক্ষেত্রের মানদণ্ড (যেমন DO-178C বা ISO 26262) timing-এর যুক্তি দাবি করে, কিন্তু কোন পদ্ধতি তা সাধারণত নির্দিষ্ট করে না; প্রকল্পের ঝুঁকি আর processor-এর জটিলতা অনুযায়ী দল বাছাই করে, প্রায়ই দুই পথ মিলিয়ে।

মূল উপলব্ধি: মাপা সর্বোচ্চ সবসময় WCET-এর নিচে বা সমান। Input-এর পরিকল্পিত coverage, কোড পড়ে loop-এর সীমা, আর যেখানে দরকার static সীমা: তিনটি মিলিয়েই একটি বিশ্বাসযোগ্য বাজেট।

প্র ০৪Cold room-এর alarm-এর latency-র প্রায় পুরোটাই ইচ্ছাকৃত: sampling আর তিন reading-এ নিশ্চিত করা। এই দেরি কমালে কী লাভ, কী ক্ষতি? একজন নকশাকার কীভাবে সংখ্যাগুলো বাছবেন?

এই পর্বের হিসাবে alarm-এর দেরি 2 s থেকে 3 s, সঙ্গে job-এর 0.06 ms. CPU-র কাজ নগণ্য; পুরো বাজেট দুটি নকশার সংখ্যা থেকে: period 1 s আর CONFIRM 3. সূত্রটি (CONFIRM − 1) × PERIOD থেকে CONFIRM × PERIOD পর্যন্ত। দুটি সংখ্যার যেকোনোটি বদলালে দেরি বদলায়, কিন্তু প্রতিটির নিজের দাম আছে।

CONFIRM কমালে (ধরুন 1) alarm দ্রুত, কিন্তু প্রতিবার দরজা খুলে ঢুকলে বা sensor-এ একটি electrical noise-এর spike-এ মিথ্যা alarm. মিথ্যা alarm-এর দাম বাস্তব: পাহারাদার কয়েকবার দৌড়ে এসে কিছু না পেলে পরে আসল alarm-এও গা করেন না। এই মানুষের আচরণ নকশার অংশ। Hysteresis (0.50 °C) একই সমস্যার আরেক সমাধান: সীমার কাছে তাপমাত্রা দুললে alarm বারবার চালু-বন্ধ হয় না।

Period কমালে (ধরুন 100 ms) একই CONFIRM-এ দেরি 0.2 থেকে 0.3 s, কিন্তু তিন reading মাত্র 0.3 s-এর মধ্যে হওয়ায় একটি ছোট দমকা বাতাসও তিনবার ধরা পড়তে পারে, অর্থাৎ নিশ্চিত করার মানে কমে যায়। আর প্রতিবার জাগার শক্তির খরচ আছে: battery-চালিত হলে period-ই আয়ুর প্রধান নির্ধারক (পর্ব ৬০ আর ৬২).

তাহলে সংখ্যা কীভাবে বাছবেন? শুরু করুন পরিণাম থেকে: ঘরের তাপমাত্রা কত দ্রুত বাড়তে পারে, আর কতক্ষণ সীমার ওপরে থাকলে ক্ষতি শুরু? সেই সময় থেকে পেছনে হিসাব: alarm-এর পরে মানুষের আসতে কত সময় লাগে, তার আগে কতটা বাজেট থাকে। এরপর মিথ্যা alarm-এর হার, যা sensor-এর noise আর দরজা খোলার ঘটনা দেখে মাপা যায়। Bangladesh-এর load-shedding-এর পরিস্থিতিও ভাবুন: বিদ্যুৎ গেলে তাপমাত্রা ধীরে বাড়ে, আর তখন alarm-এর সঙ্গে “বিদ্যুৎ নেই” আলাদা বার্তা বেশি কাজের। এই প্রক্রিয়ায় সংখ্যাগুলো যুক্তির ফল, অনুমানের নয়, আর latency budget-এর টেবিল সেই যুক্তির লিখিত রূপ।

মূল উপলব্ধি: End-to-end latency-র বড় অংশ প্রায়ই CPU নয়, নকশার সিদ্ধান্ত: sampling আর filtering. দ্রুত alarm আর মিথ্যা alarm-এর মধ্যে ভারসাম্য সংখ্যায় লিখে বাছাই করাই real-time নকশার কাজ।

প্র ০৫১৯৭৩ সালে Liu আর Layland periodic task-এর utilisation-এর একটি সীমা দেন। পঞ্চাশ বছর পরেও কেন U-এর হিসাব প্রথম ধাপ, অথচ শুধু U-এর ওপর ভরসা বিপজ্জনক?

C. L. Liu আর James Layland-এর ১৯৭৩ সালের প্রবন্ধ (Journal of the ACM) real-time scheduling তত্ত্বের অন্যতম ভিত্তি। তাঁরা একটি সরল মডেল নেন: স্বাধীন periodic task, deadline = period, preemptive scheduler. সেখানে দেখান, ছোট period-কে বেশি priority দিলে (rate-monotonic) n টি task-এর মোট U যদি n(21/n − 1)-এর বেশি না হয়, সব deadline নিশ্চিত; n বড় হলে সীমা প্রায় 0.693-এর দিকে নামে। একই প্রবন্ধে dynamic priority-র নীতি (যার deadline আগে সে আগে) এক CPU-তে U ≤ 1 পর্যন্ত সব deadline রাখতে পারে, তাও দেখানো হয়।

U এখনো প্রথম ধাপ, কারণ এটি সবচেয়ে সস্তা হিসাব: প্রতিটি task-এর দুটি সংখ্যা, একটি ভাগ আর একটি যোগ। U > 1 হলে আর কিছু ভাবার দরকার নেই, নকশা বদলাতে হবে। U খুব ছোট হলে (cold room-এর 1%) বোঝা যায় CPU-র ক্ষমতা সমস্যা নয়; তখন মনোযোগ যায় latency-র অন্য উৎসে: blocking, critical section, আর peripheral-এর অপেক্ষা। আর U দেখায় কতটা জায়গা আছে নতুন feature-এর জন্য, বা কত কম clock-এ চালিয়ে শক্তি বাঁচানো যায়।

কিন্তু শুধু U-এর ওপর ভরসার তিনটি বিপদ। এক, এই পর্বের P আর S: U = 0.8 ≤ 1, তবু ভুল priority-তে P deadline হারিয়েছে; U ক্রমের কথা কিছু বলে না। দুই, Liu–Layland সীমা যথেষ্ট শর্ত, প্রয়োজনীয় নয়: সীমা পেরোলেও task-গুচ্ছ নিরাপদ হতে পারে, তাই সঠিক উত্তরের জন্য response-time analysis লাগে, যা ১৯৮০-এর দশকে Joseph ও Pandya সহ গবেষকদের কাজে এসেছে বলে সাধারণত উল্লেখ করা হয়। তিন, মডেলের অনুমান বাস্তবে ভাঙে: task-রা mutex ভাগ করে (blocking, পর্ব ৫৭), ISR আর polled UART-এর অপেক্ষা থাকে, release-এ jitter থাকে। প্রতিটি অনুমান ভাঙলে সূত্রে একটি পদ যোগ করতে হয়।

আর সবকিছুর নিচে C নিজেই একটি অনুমান: এই পর্বে দেখা গেল একই job-এর মাপা সর্বোচ্চ input অনুযায়ী 886 বা 1155. ভুল C দিয়ে নিখুঁত সূত্রও ভুল উত্তর দেয়।

মূল উপলব্ধি: U একটি দ্রুত প্রথম ছাঁকনি: U > 1 মানে অসম্ভব, খুব ছোট U মানে CPU সমস্যা নয়। মাঝের সব ক্ষেত্রে priority-র ক্রম, blocking আর নির্ভরযোগ্য C নিয়ে response-time analysis-ই আসল উত্তর।

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর কোর্সের virtual board, RTOS simulator বা Python-এ চালিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — deadline-পাহারাদার periodic loop: RTOS ছাড়া একটি Cortex-M firmware-এ SysTick প্রতি 10 ms-এ ticks বাড়ায়। প্রতি 1 s-এ একটি job() চালাতে একটি loop লিখুন যা (ক) drift করে না, (খ) job দেরিতে শুরু হলে বা deadline (পরের release) পেরিয়ে শেষ হলে একটি miss counter বাড়ায়, (গ) একটি job বাদ পড়লে পরেরগুলো ঠিক সময়ে ফিরিয়ে আনে।
    #define PERIOD 100u                     /* 100 × 10 ms = 1 s */
    static volatile uint32_t ticks;         /* SysTick ISR: ticks++ */
    static uint32_t miss;
    
    void periodic_loop(void)
    {
        uint32_t next = ticks + PERIOD;      /* প্রথম release */
        for (;;) {
            while ((int32_t)(ticks - next) < 0)
                __WFI();                     /* release পর্যন্ত ঘুম */
            job();
            uint32_t deadline = next + PERIOD;
            if ((int32_t)(ticks - deadline) >= 0) {
                miss++;                      /* deadline পেরিয়েছে */
                /* বাদ পড়া release-গুলো গুনে লাফ, জমিয়ে চালানো নয় */
                while ((int32_t)(ticks - (next + PERIOD)) >= 0)
                    next += PERIOD;
            }
            next += PERIOD;                  /* পরম সময়: drift নেই */
        }
    }

    মূল সিদ্ধান্ত তিনটি। next += PERIOD পরের release-কে আগের release থেকে গোনে, তাই job-এর সময় জমে না; reference coldroom.c-এ এই নকশায় বিশ সেকেন্ড পরেও লাইন 20000.04 ms-এ। (int32_t)(ticks - next) wrap-safe তুলনা, ৩২ বিটের counter wrap করলেও ঠিক (পর্ব ৪৪). Deadline ভাঙলে বাদ পড়া release-গুলো লাফিয়ে যাওয়া firm deadline-এর নীতি: পুরোনো reading জমিয়ে পরপর চালানো অর্থহীন, তাই সরাসরি পরের ভবিষ্যৎ release-এ ফেরা। Soft কাজে (যেমন একটি গণনা যার প্রতিটি ফল দরকার) বিপরীত নীতি, backlog চালানো, বেছে নিতে পারেন; rtos_sim-এর আচরণ সেটিই (Spec decision 34). Interrupt বন্ধ রেখে WFI-এর হারানো জাগরণের সূক্ষ্মতা পর্ব ৪৩-এ; এখানে SysTick প্রতি 10 ms-এ জাগায়, তাই সবচেয়ে খারাপে এক tick দেরি।

  2. ভুল খুঁজুন — “এক সেকেন্ড পরপর” আর “WCET”: একজন নকশাকারের নোট: “লুপ while (1) { read_and_send(); delay_ms(1000); } প্রতি 1 s-এ চলে। read_and_send() পাঁচবার মেপেছি, সর্বোচ্চ 1.48 ms, তাই WCET = 1.48 ms, আর এক মাস পরেও reading ঠিক সেকেন্ডের মাথায় হবে।” দুটি ভুল দেখান, আর একদিনে সময় কতটা সরবে তা হিসাব করুন (job প্রতিবার 1.4757 ms ধরুন).

    ভুল ১, period: লুপের period 1000 ms নয়, 1000 ms + job-এর সময় (+ delay-এর নিজের ভুল). প্রতি period-এ 1.4757 ms সরে; একদিনের ৮৬,৪০০টি job-এ প্রায় 86400 × 1.4757 ms ≈ 127.5 s, অর্থাৎ দুই মিনিটের বেশি। অংশ ৩-এর jitter.py ঠিক এই সংখ্যাই দিয়েছে (115200 baud-এ 17 অক্ষর ধরে)। এক মাসে প্রায় এক ঘণ্টা। সমাধান পরম release: next += T, অনুশীলন ১-এর মতো।

    ভুল ২, WCET: পাঁচটি মাপের সর্বোচ্চ হলো high-water mark, WCET নয়। কোন input-এ মাপা, তা না জানলে এটি নিচের সীমাও দুর্বল। এই পর্বের board-এ README-র ২০টি job-এ সর্বোচ্চ 886 cycle, আর ভিন্ন input-এ (alarm বদল + telemetry + তিন অঙ্কের তাপমাত্রা) 1155. ঠিক পথ: প্রতিটি শাখা আর অঙ্কসংখ্যার সর্বোচ্চ ইচ্ছা করে চালানো, তারপর margin, আর কারণ লিখে রাখা। এছাড়া আসল chip-এ polled UART-এর অপেক্ষা job-এর অংশ, তাই telemetry-র লাইন থাকলে সময় অনেক বেশি (সবচেয়ে খারাপ job-এ 119 অক্ষর = 10.33 ms).

  3. আগে বলুন — sporadic কাজ একটু আগে বা পরে: Preemptive fixed-priority scheduler, এক tick-এ এক task. Periodic P: priority 1, C = 2, T = D = 5, release 0, 5, 10, 15. Sporadic S: priority 2 (বেশি জরুরি), C = 4, একবার আসে। (ক) S tick 4-এ এলে P-এর দ্বিতীয় job (release 5) কখন শেষ হবে, deadline রক্ষা হবে কি? (খ) S tick 7-এ এলে P-এর কোন job-এর response বাড়বে, কত হবে?

    (ক) S চলে tick 4 থেকে 7, শেষ 8-এ। P-এর দ্বিতীয় job 5-এ release হয়ে অপেক্ষা করে, চলে 8 আর 9, শেষ 10-এ: response 5, deadline 10. ঠিক deadline-এর মুহূর্তে শেষ, তাই রক্ষা, একটুও জায়গা নেই। (খ) P-এর দ্বিতীয় job 5 আর 6-এ চলে 7-এ শেষ, S আসার আগেই। S চলে 7 থেকে 10. তৃতীয় job 10-এ release, কিন্তু tick 10-এ S চলছে; P চলে 11, 12, শেষ 13-এ: response 3, deadline 15 রক্ষা। দুটি উত্তরই reference lab-এর rtos_sim.py run-এ মেলানো: (ক)-এর Gantt-এ P ##...---####...##..., (খ)-তে P ##...##...-##..##.... অংশ ২-এ S tick 6-এ এলে P deadline হারিয়েছিল: একই কাজ, এক tick-এর পার্থক্যে ফল বদলায়, তাই worst case খুঁজতে হয় সব phase-এ।

  4. হিসাব — নতুন নকশায় alarm-এর বাজেট: বিদ্যুৎ বাঁচাতে একজন প্রস্তাব দিলেন cold room-এর reading প্রতি 2 s, CONFIRM আগের মতো 3. মালিকের শর্ত: সীমা পেরোনোর 5 s-এর মধ্যে alarm. (ক) সবচেয়ে ভালো আর সবচেয়ে খারাপ দেরি কত (job-এর 0.0634 ms ধরে)? (খ) শর্ত রক্ষা হয় কি? (গ) period 1 s রেখে CONFIRM 2 করলে?

    সূত্র: দেরি (CONFIRM − 1) × PERIOD থেকে CONFIRM × PERIOD পর্যন্ত, সঙ্গে R. (ক) 2 × 2 s = 4 s থেকে 3 × 2 s = 6 s, সঙ্গে 0.0634 ms. অংশ ৫-এর alarm_lat.py-তে PERIOD = 2000 বসিয়ে চালালে: সেরা 4000.5634 ms, সবচেয়ে খারাপ 5999.5634 ms (phase-এর অর্ধ-ms ধাপের কারণে প্রান্ত থেকে 0.5 ms ভেতরে). (খ) না: খারাপ phase-এ প্রায় 6 s, শর্ত 5 s. গড় হয়তো 5 s, কিন্তু real-time প্রতিশ্রুতি গড়ের নয়। (গ) 1 s থেকে 2 s (মডেলে 1000.5634 থেকে 1999.5634 ms): শর্ত সহজে রক্ষা, কিন্তু মাত্র দুটি reading-এ নিশ্চিত হওয়ায় দরজা খোলার মতো ছোট ঘটনায় মিথ্যা alarm-এর সম্ভাবনা বাড়ে। মাঝের সমাধান হতে পারে period 1.5 s আর CONFIRM 3: 3 s থেকে 4.5 s; বাছাই নির্ভর করে শক্তি, মিথ্যা alarm আর শর্তের ভারসাম্যে (ভাবনার প্রশ্ন ৪).

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

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

ক্রমএকটি firmware-এর periodic job-এর জন্য মাপার পথে (measurement-based) WCET-এর বাজেট বানানোর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Job-এর শুরু আর শেষ ঠিক করা, আর deadline লিখে রাখা
  2. শুরু আর শেষে timestamp বসানো, মাপার নিজের খরচ জানা
  3. প্রতিটি শাখা আর loop-এর সর্বোচ্চ ঘোরা চালায় এমন input বানানো
  4. সব run-এর সর্বোচ্চ (high-water mark) নেওয়া
  5. কারণসহ margin যোগ করে বাজেট আর utilisation হিসাব
  6. আসল chip-এ বা static সীমা দিয়ে বাজেট মিলিয়ে দেখা

একটি গুদামের ঠান্ডা ঘরের monitor প্রতি 1 s-এ তাপমাত্রা পড়ে। একটি reading দেরিতে এলে সেটি ফেলে দেওয়া হয়, কারণ পরের reading শিগগিরই আসছে, আর মাঝেমধ্যে একটি বাদ পড়লে কোনো ক্ষতি নেই। এই reading-এর deadline কোন শ্রেণির?

  • Hard real-time
  • Soft real-time
  • Firm real-time
  • Real-time নয়, কারণ 1 s খুব ধীর

Sporadic task আর aperiodic task-এর মূল পার্থক্য কী?

  • Sporadic-এর দুই আগমনের ন্যূনতম ব্যবধান জানা, aperiodic-এর নয়
  • Sporadic ঘড়ির তালে আসে, aperiodic ঘটনায়
  • Sporadic-এর priority সবসময় বেশি
  • Aperiodic-এর deadline থাকে, sporadic-এর থাকে না

এক CPU-তে দুটি task: P (C = 2, T = D = 5) আর S (C = 4, ন্যূনতম ব্যবধান 10, D = 10). মোট U = 0.8. Preemptive fixed priority-তে S-কে বেশি priority দিলে কী হয়?

  • U ≤ 1, তাই সব deadline নিশ্চিত রক্ষা
  • Liu–Layland সীমার নিচে, তাই যেকোনো ক্রমে নিরাপদ
  • U > 1, তাই কোনো ক্রমেই সম্ভব নয়
  • P একটি deadline হারাতে পারে; ছোট period-কে বেশি priority দিলে দুটিই রক্ষা

একটি job ২০ বার চালিয়ে সর্বোচ্চ 886 cycle মাপা হলো। এই সংখ্যাটি সম্পর্কে কোনটি ঠিক?

  • এটিই WCET, কারণ ২০টি run যথেষ্ট
  • এটি WCET-এর একটি নিচের সীমা; আসল WCET এর সমান বা বেশি
  • এটি গড় execution time
  • এটি WCET-এর একটি ওপরের সীমা

RTOS ছাড়া একটি firmware-এ SysTick প্রতি 10 ms-এ ticks বাড়ায়। প্রতি 1 s-এর কাজের জন্য কোন লুপ সময়ের সঙ্গে সরে যায় (drift)?

  • if (ticks >= next) { next += 100; job(); }
  • next += 100; while (ticks < next) __WFI(); job();
  • job(); delay_ms(1000);
  • কোনোটিই নয়, সবাই ঠিক 1 s পরপর চলে

একটি ঠান্ডা ঘরের monitor প্রতি 1 s-এ তাপমাত্রা পড়ে আর পরপর 3টি সীমার বাইরের reading পেলে alarm দেয়। Job-এর নিজের সময় নগণ্য ধরলে, সীমা পেরোনো থেকে alarm পর্যন্ত সবচেয়ে খারাপ দেরি প্রায় কত?

  • প্রায় 3 s
  • প্রায় 1 s
  • প্রায় 2 s
  • প্রায় 10 s, কারণ telemetry প্রতি 10 s-এ

শব্দকোষ

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

মনে রাখুন

  1. Real-time = নিশ্চিত সময়: hard (পেরোলেই ব্যর্থতা), firm (দেরির ফল ফেলে দেওয়া), soft (দেরিতে মান কমে); শ্রেণি পরিণাম দিয়ে, গতি দিয়ে নয়, আর প্রতিটি deadline-এর আলাদা।
  2. Task-এর মডেল: release, C, T, D; R = শেষ − release, R ≤ D হলে রক্ষা। Periodic ঘড়িতে, sporadic-এর ন্যূনতম ব্যবধান জানা, aperiodic-এর নয়।
  3. Jitter কাঁপে, drift জমে: পরের release আগের release থেকে গুনুন (next += T), কাজ শেষ থেকে নয়।
  4. WCET: মাপা সর্বোচ্চ শুধু নিচের সীমা; প্রতিটি শাখা আর সংখ্যার সর্বোচ্চ চালান, margin-এর কারণ লিখুন, দরকারে static সীমা। Board-এর cycle আসল chip-এর সময় নয়।
  5. Latency budget আর U: end-to-end দেরি ধাপে ভাগ করে লিখুন (cold room: 2 s থেকে 3 s + R); U = Σ C/T, U > 1 অসম্ভব, U ≤ 1 যথেষ্ট নয়।

পরের পর্বে: পর্ব ৫৫ (Super loop আর state machine — RTOS ছাড়া firmware). SysTick-এর tick দিয়ে সময় রাখা super loop, task table দিয়ে cooperative scheduling, smart scale-এর UI-র state machine board-এ চালিয়ে দেখা, আর কোন সীমায় পৌঁছে RTOS দরকার হয়।

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

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