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

এমবেডেড memory — stack-এর আকার, heap এড়ানো আর static allocation

Embedded Memory — Stack Sizing, Avoiding the Heap and Static Allocation

Taught in Bangla, this lesson budgets a firmware's 20 KiB SRAM. It measures stack growth through nested calls and the 32- or 36-byte interrupt frame on the course's virtual BG-M3 board, computes worst-case depth from Clang's -fstack-usage plus the call graph, and paints the stack to find a 76-byte high-water mark against a 112-byte worst case. A recursion overflow silently corrupts tare_g; guard words and a low stack placement catch it. In-page Python models heap fragmentation; static pools replace malloc.

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

  • Map file থেকে একটি firmware-এর flash আর SRAM বাজেট বানানো, আর static, stack ও heap-এর পার্থক্য বলা
  • Nested function call আর ISR-এর frame মিলিয়ে stack কতটা নামে, ধাপে ধাপে হিসাব করা
  • -fstack-usage আর call graph দিয়ে সবচেয়ে খারাপ stack-এর হিসাব, tail call আর recursion-এর প্রভাবসহ
  • Stack painting দিয়ে high-water mark মাপা, আর মাপা ফল কেন প্রমাণ নয় তা বোঝা
  • Heap fragmentation দেখা, আর pool, ring buffer ও অন্যান্য static allocation-এর নকশা বেছে নেওয়া

১ · ২০ KiB-এর সংসার — firmware-এর memory বাজেট

পর্ব ৩৪-এ (Embedded C আর volatile) দেখেছেন, firmware চলে OS ছাড়া, freestanding পরিবেশে। সেই পর্বের টেবিলে একটি সারি ছিল: “মেমরি: heap এড়ানো, static বরাদ্দ (পর্ব ৩৯)”। এই পর্ব সেই প্রতিশ্রুতি রাখে। কোর্সের virtual বাজারঘর board (BG-M3, আসল কোনো পণ্য নয়, Cortex-M3-এর আদলে বানানো) দেয় 128 KiB flash আর 20 KiB SRAM (reference lab-এর Spec decision 18). মাপটি কাল্পনিক নয়: STM32F103-এর কয়েকটি সংস্করণেও 20 KiB SRAM থাকে, আর Arduino Uno-র ATmega328P-এ মাত্র 2 KiB. এই পর্বে hex লেখা হবে C-র ধাঁচে, 0x20005000.

উপমা — বাজারঘরের দোকানঘর: দোকানে তিন রকম জায়গা। দেয়ালের তাকগুলো দোকান খোলার দিনই মাপমতো বানানো, প্রতিটিতে কী থাকবে লেখা (static). ক্যাশ কাউন্টারের ওপর একটি ট্রে, যেখানে খদ্দের এলে রসিদ, খুচরা আর ব্যাগ একটার ওপর একটা জমে, খদ্দের গেলে ওপর থেকে উঠে যায় (stack). আর পেছনের খোলা মেঝে, যেখানে যে-কেউ যখন-তখন যেকোনো মাপের বস্তা রাখে আর তোলে (heap). তাক কখনো এলোমেলো হয় না; ট্রে উপচে পড়তে পারে, যদি একসঙ্গে অনেক খদ্দের আসেন; আর মেঝেতে ছোট ছোট ফাঁক জমে, শেষে বড় একটি বস্তা রাখার মতো টানা জায়গা থাকে না।

প্রথম কাজ বাজেট: কোন জিনিস কোথায় কতটা জায়গা নিচ্ছে। এর উৎস linker-এর map file; পড়ার পুরো কৌশল পর্ব ৩১-এ (Memory map আর linker script), আর build-এর কোন ধাপে map file তৈরি হয় তা পর্ব ৩৭-এ (Cross-compilation আর build); এখানে শুধু ফল। আমার lab-এ (~/lab, নিজের zig cache-সহ) reference lab-এর scale.c আর coldroom.c হুবহু build করা হলো; scale.map reference-এর map-এর সঙ্গে byte-ধরে মিলেছে।

সত্যিকারের run — ld.lld 22.1.8-এর map, output section-এর লাইন
--- scale.map ---
 8000000  8000000       60     4 .isr_vector
 8000060  8000060      82c     4 .text
20000000 20000000        0     1 .data
20000000 20000000        c     4 .bss
--- coldroom.map ---
 8000060  8000060      6d8     4 .text
20000000 20000000        4     4 .bss
খাতSmart scaleCold-room monitorকোথায়
Vector table + কোড + const0x60 + 0x82C = 96 + 2092 = 2188 B (1.67%)96 + 0x6D8 = 96 + 1752 = 1848 B (1.41%)flash
শুরুর মানসহ variable (.data)0 B0 BSRAM (মান flash-এ)
শূন্য-শুরু variable (.bss)12 B4 BSRAM
Stack-এর জন্য বাকি0x20005000 − 0x2000000C = 20468 B20476 BSRAM-এর ওপরের অংশ
Stack সত্যিই কতটা লাগে? — এই পর্বের মূল প্রশ্ন (অংশ ৪ আর ৫)—
Heap0 B0 Bনেই

দুটি device-ই ছোট, তাই জায়গার অভাব নেই। কিন্তু ঠিক এখানেই একটি ফাঁদ। Map file বলে স্থির খরচ: কোড, global আর static variable. Stack-এর মাপ map file-এ নেই; linker শুধু জানে কতটা জায়গা বাকি থাকল। আর heap-এর খরচ নির্ভর করে চলার সময় কে কবে কী চাইল তার ওপর। একটি firmware হয়তো ল্যাবের টেবিলে মাসের পর মাস ঠিক চলে, আর কোনো এক দুপুরে, ঠিক যখন tare বোতাম চাপা আর UART interrupt একসঙ্গে এল, stack এক byte বেশি নেমে কারও data নষ্ট করে। তাই এমবেডেড কাজে memory-র প্রশ্ন দুটি: “কতটা আছে” (map file), আর “সবচেয়ে খারাপ মুহূর্তে কতটা লাগবে” (হিসাব আর মাপ)।

Reference lab-এর linker script এ বিষয়ে একটি ছোট পাহারাও বসিয়েছে। bazarghar.ld-এর শেষ লাইন:

_min_stack = 2K;                         /* link fails if less than this is left */
ASSERT(_estack - . >= _min_stack, "not enough SRAM left for the stack")

অর্থাৎ static data বেড়ে stack-এর জন্য 2 KiB-এর কম রাখলে build-ই ব্যর্থ হবে। ভালো অভ্যাস, তবে 2 KiB সংখ্যাটি নিজে একটি অনুমান। কোন অনুমান যথেষ্ট, তা জানতে stack-এর আচরণ বুঝতে হবে।

২ · তিন রকম জায়গা — static, stack আর heap

C-র প্রতিটি variable তিনটির একটিতে বাস করে। তাদের পার্থক্য তিন প্রশ্নে: মাপ কে, কখন ঠিক করে; জায়গা কতদিন থাকে; আর জায়গা না পেলে ভুল কখন ধরা পড়ে।

দিকStatic (.data/.bss)StackHeap
উদাহরণstatic uint32_t ms_ticks;function-এর local, ফেরার ঠিকানা, ISR framemalloc(96)
মাপ ঠিক হয়compile আর link-এর সময়প্রতিটি frame compile-এ, মোট গভীরতা চলার সময়চলার সময়, প্রতিটি অনুরোধে
আয়ুপুরো সময়function ফেরা পর্যন্তfree পর্যন্ত (বা চিরকাল, ভুলে গেলে)
জায়গা না পেলেlink error, build-এর সময়নীরবে অন্যের data নষ্ট বা fault, চলার সময়NULL, চলার সময়, হয়তো মাস পরে
সময়ের নিশ্চয়তাখরচ শূন্যএকটি push/sub spখোঁজার সময় অবস্থাভেদে বদলায়

টেবিলের “জায়গা না পেলে” সারিটিই এমবেডেড নকশার মূল যুক্তি। Static বরাদ্দের ভুল ধরা পড়ে আপনার কম্পিউটারে, build-এর সময়; stack আর heap-এর ভুল ধরা পড়ে মাঠে, দোকানে, গুদামে। তাই এমবেডেড জগতের অভ্যাস: যতটা সম্ভব static, stack-এর আকার হিসাব করে প্রমাণসহ, আর heap প্রায় কখনো নয়।

এই কোর্সের board-এ heap একেবারেই নেই। পরীক্ষা হিসেবে একটি firmware-এ malloc(96) ডাকা হলো। প্রথম চেষ্টায় #include <stdlib.h>-এ compiler বলল header পাওয়া যায়নি, কারণ -ffreestanding -nostdlib build-এ শুধু compiler-এর নিজের ছোট header-গুলো থাকে। malloc-এর ঘোষণা হাতে লিখে দিলে compile হয়, কিন্তু link-এ:

সত্যিকারের run — heapuse.c, Clang 22.1.8 + ld.lld
ld.lld: error: undefined symbol: malloc
>>> referenced by heapuse.c
>>>               heapuse.heapuse.o:(main)
link failed

আসল প্রকল্পে newlib বা অন্য কোনো C library যোগ করলে malloc পাওয়া যায়, আর তখন linker script-এ heap-এর জায়গাও রাখতে হয় (সাধারণত .bss-এর শেষ থেকে ওপরের দিকে, stack-এর দিকে মুখ করে)। Heap কীভাবে কাজ করে, malloc-এর ভেতরের খাতা আর first-fit খোঁজা, তা C কোর্সে আছে: C পর্ব ২০ (ডায়নামিক মেমরি) আর C পর্ব ৪৭ (নিজের malloc বানানো)। এখানে শুধু এমবেডেড দিক: কেন এড়ানো হয় (অংশ ৭), আর বদলে কী (অংশ ৮)।

ছবি ৩৯.১ — Smart scale-এর SRAM, stack painting-এর পরে

নিচে static data, ওপরে stack; মাঝের বিশাল অংশ রং করা আর কখনো ছোঁয়া হয়নি (আকার মাপমতো নয়)

Smart scale-এর SRAM-এর মানচিত্র main 24 B SP 0x20004FE8 uart_put_fixed2 52 B 0xC5C5C5C5 রং করা, কখনো ছোঁয়া হয়নি 20384 B heap থাকলে এখানে, ওপরে .bss 20 B ms_ticks … 0x20005000 0x20004FB4 0x20000014 0x20000000 _estack high- water 76 B _ebss SRAM শুরু stack নামে
ছবি ৩৯.১ — ঠিকানা আর মাপ board-এর সত্যিকারের run থেকে (scale_hw.elf: reference scale.c + stack painting-এর কোড, তাই .bss 12 নয়, 20 byte). অংশ ৫-এর stepper এই ছবির প্রতিটি সংখ্যা ধাপে ধাপে দেখায়।

৩ · Stack কীভাবে নামে — nested call আর ISR-এর frame

8085-এ CALL ফেরার ঠিকানা stack-এ রাখত আর PUSH register (পর্ব ১২), 8086-এ BP দিয়ে frame বানানো হতো (পর্ব ১৮)। সেই মূল ধারণা এখানে আর নতুন করে নয়। Cortex-M-এ SP (reset-এ MSP) নিচের দিকে নামে, আর প্রতিটি function নিজের stack frame বানায় এভাবে: শুরুতে push দিয়ে যে register-গুলো সে নষ্ট করবে (callee-saved) আর LR, তারপর দরকার হলে sub sp, #n দিয়ে local-এর জায়গা। আর interrupt এলে hardware নিজেই আটটি word রাখে: R0–R3, R12, LR, ফেরার PC আর xPSR (পর্ব ৩০-এ exception আর NVIC).

Stack কতটা নামে তা নিজের চোখে দেখতে আমার lab-এ stack.c লেখা হলো: scale-এর একটি মাপের ছোট রূপ। main ডাকে scale_task, সে ডাকে read_filtered (আটটি ADC sample) আর তারপর report (একটি ৩২ byte-এর লেখার buffer আর uart_put_i32). প্রতিটি function শুরুতে নিজের SP একটি global array-তে লিখে রাখে, আর সবচেয়ে গভীর adc_read ইচ্ছা করে SysTick-কে pending করে, যাতে ISR ঠিক সেই মুহূর্তে আসে। Build-এর flag reference lab-এর মতোই (-O2, thumbv7m, Cortex-M3).

সত্যিকারের run — python -B board.py run build/stack.elf
[     2.2930 ms] UART: raw=400
[     4.3894 ms] UART: painted words: 5108
[     4.4256 ms] UART: main SP=0x20005000 used=0
[     4.4656 ms] UART: scale_task SP=0x20004FF8 used=8
[     4.5100 ms] UART: read_filtered SP=0x20004FD8 used=40
[     4.5506 ms] UART: adc_read SP=0x20004FD8 used=40
[     4.5898 ms] UART: report SP=0x20004FD8 used=40
[     4.6289 ms] UART: SysTick SP=0x20004FB8 used=72
[     4.6880 ms] UART: high-water mark at 0x20004FA8 -> max stack used 88 bytes
[     4.7302 ms] UART: ebss=0x20000020 estack=0x20005000
[     4.7311 ms] exit(0) after 37849 cycles

সংখ্যাগুলো প্রথম দেখায় অদ্ভুত। read_filtered-এ আটটি sample-এর array থাকলেও তার frame 32 byte, আর report, যে scale_task-এর ভেতর থেকে ডাকা, তার SP scale_task-এর চেয়েও ওপরে! উত্তর আসল assembly-তে (clang -S -O2, প্রাসঙ্গিক লাইন):

সত্যিকারের run — stack.c, Clang 22.1.8 -O2
scale_task:
        push    {r7, lr}
        ...
        bl      read_filtered
        pop.w   {r7, lr}
        b       report                @ tail call: frame আগেই ফেরত
read_filtered:
        push.w  {r4, r5, r6, r7, r8, r9, r10, lr}   @ 8 × 4 = 32 B
        ...                           @ 8টি sample register-এ, array নেই
report:
        push    {r4, lr}
        sub     sp, #32               @ char line[32]

দুটি optimization stack বাঁচিয়েছে। read_filtered-এর loop খুলে ফেলে Clang আটটি sample আটটি register-এ রেখেছে, stack-এর array-এর দরকারই পড়েনি; শুধু সেই register-গুলোর পুরোনো মান রাখতে 32 byte. আর scale_task-এর শেষ কাজ report ডাকা, তাই compiler একটি tail call বানিয়েছে: নিজের frame ফেরত দিয়ে (pop) সোজা b report. ফলে report চলে main-এর ঠিক নিচে, এক স্তর কম গভীরে। adc_read নিজে কাউকে ডাকে না, একটি leaf function; LR-এ থাকা ফেরার ঠিকানা stack-এ রাখার দরকার নেই, তাই তার frame 0 byte.

প্রতিটি ধাপের পরে
চলছে
নির্দেশ
SP
মোট ব্যবহার
এই স্তরের অংশ
  1. main. Reset-এ MSP = 0x20005000 (vector table-এর প্রথম word). main কখনো ফেরে না (শেষে board_exit), তাই compiler তার জন্য কোনো register রাখেনি: frame 0 byte.
  2. scale_task. push {r7, lr}: দুটি word, 8 byte. SP 0x20004FF8. LR রাখতেই হলো, কারণ এই function নিজে আরও function ডাকবে।
  3. read_filtered. আটটি register (R4–R10 আর LR) একসঙ্গে: 32 byte, SP 0x20004FD8. আটটি sample এখন register-এ, তাই stack-এ কোনো array নেই।
  4. adc_read — leaf. কাউকে ডাকে না, তাই push নেই: SP একই 0x20004FD8. এখানে SCB->ICSR-এ PENDSTSET বিট লিখে SysTick pending করা হলো।
  5. SysTick এল। Hardware R0–R3, R12, LR, PC, xPSR রাখল: 8 × 4 = 32 byte. SP 0x20004FD8 আগেই 8-এর গুণিতক, তাই কোনো ফাঁকা word লাগেনি; SP 0x20004FB8, মোট 72 byte. Handler নিজে leaf, তার frame 0.
  6. Tail call-এ report. ISR ফিরল, read_filtered ফিরল। scale_task pop.w {r7, lr} দিয়ে নিজের 8 byte ফেরত দিয়ে b report করল। report 8 + 32 = 40 byte নিল, তাই SP আবার 0x20004FD8, ৪৮ নয়।
  7. সবচেয়ে গভীর বিন্দু। report ডাকল uart_put_i32 (frame 48 byte): SP 0x20004FA8, মোট 88 byte. Stack painting-ও ঠিক এই ঠিকানা পেয়েছে: high-water mark at 0x20004FA8.

একটি খুঁটিনাটি মনে রাখুন: interrupt-এর frame সবসময় 32 byte নয়। Board (Spec decision 19) আর পরের revision-এর Cortex-M3 interrupt-এর মুহূর্তে SP 8-এর গুণিতক না হলে আগে 4 byte ফাঁকা রাখে, আর xPSR-এর বিট ৯-এ তা লিখে রাখে। আমার align.c-তে একটি function-এর frame 44 byte (8-এর গুণিতক নয়) রেখে ঠিক তখন SysTick আনা হলো:

সত্যিকারের run — align.elf
[     0.1010 ms] UART: odd() SP=44 B used, ISR SP=80 B used, frame+pad=36 B, xPSR bit9=1 r=23

অর্থাৎ হিসাবে প্রতিটি interrupt-এর জন্য 32 নয়, 36 byte ধরাই নিরাপদ। FPU-সহ chip-এ (যেমন Cortex-M4F) floating-point register-ও রাখতে হলে frame আরও বড় হয় (FPU-সহ পূর্ণ frame ২৬ word, 104 byte); কোর্সের Cortex-M3-এ FPU নেই।

৪ · Stack-এর আকার হিসাব — -fstack-usage আর call graph

সবচেয়ে খারাপ stack-এর হিসাবের সূত্রটি সরল:

সূত্র

দরকারি stack = (main থেকে সবচেয়ে গভীর call পথের frame-এর যোগফল) + (প্রতিটি preemption স্তরের জন্য: 36 byte interrupt frame + সেই স্তরের সবচেয়ে গভীর handler-এর পথ) + নিরাপত্তা-মার্জিন

এর জন্য দুটি তথ্য লাগে: প্রতিটি function-এর frame কত, আর কে কাকে ডাকে। প্রথমটি দেয় compiler-এর -fstack-usage option. এটি GCC-তে বহু বছর ধরে আছে; Clang-এ তুলনামূলক নতুন, আর পুরোনো লেখায় প্রায়ই পাবেন “Clang-এ নেই”। তাই কথা নয়, পরীক্ষা: কোর্সের Clang 22.1.8 (ziglang 0.17.1)-এ flag-টি দিয়ে build করতেই প্রতিটি object-এর পাশে একটি .su ফাইল তৈরি হলো:

সত্যিকারের run — build/stack.*.su (Clang 22.1.8, -O2 -fstack-usage)
stack.c:20:SysTick_Handler      0       static
stack.c:74:main                 0       static
stack.c:60:scale_task           8       static
stack.c:35:read_filtered        32      static
stack.c:47:report               40      static
stack.c:26:adc_read             0       static
bglib.c:23:uart_put_u32         48      static
bglib.c:35:uart_put_i32         48      static
bglib.c:45:uart_put_fixed2      52      static

প্রতিটি লাইনে ফাইল, লাইন, function, byte, আর একটি শব্দ: static মানে frame-এর মাপ স্থির। VLA (চলার সময় মাপ ঠিক হওয়া array) থাকলে লেখা হয় dynamic: একটি পরীক্ষা-ফাইলে volatile uint32_t buf[n]; লিখতেই এল vla.c:2:sum_n 24 dynamic, অর্থাৎ 24 byte-এর সঙ্গে আরও যত লাগে, যা compiler জানে না। এমবেডেড কোডে VLA আর alloca তাই প্রায় নিষেধ। আর frame-এর একটি সীমা বেঁধে দিতে -Wframe-larger-than=32 দিলে Clang প্রতিটি বড় frame-এ সতর্ক করল, যেমন warning: stack frame size (40) exceeds limit (32) in 'report'.

Optimization-এর মাত্রা এই সংখ্যাগুলো আমূল বদলায়। একই stack.c -O0-এ build করলে .su-তে main 80, read_filtered 56, report 56 byte, আর board-এ মাপা high-water mark 88 নয়, 220 byte, আড়াই গুণ। কাজেই হিসাব আর মাপ, দুটিই release build-এ করতে হয়, যেটি সত্যিই মাঠে যাবে।

দ্বিতীয় তথ্য, কে কাকে ডাকে, অর্থাৎ call graph. আমার lab-এর callgraph.py Clang-এর -S output থেকে প্রতিটি bl (সাধারণ call) আর b (tail call) তুলে নিয়েছে। নিচের ব্লকে সেই আসল সংখ্যা আর edge দিয়ে সবচেয়ে খারাপ পথ খোঁজা হলো; ~ চিহ্ন মানে tail call.

# stack.c-এর আসল -fstack-usage (byte) আর -S থেকে পাওয়া call edge; "~" = tail call
FRAME = {"main": 0, "scale_task": 8, "read_filtered": 32, "adc_read": 0,
         "report": 40, "uart_put_i32": 48, "uart_put_u32": 48, "put_hex": 16,
         "uart_puts": 0, "uart_putc": 0, "uart_init": 0, "SysTick_Handler": 0,
         "fib": 16}
CALLS = {"main": ["uart_init", "scale_task", "put_hex", "uart_puts", "uart_put_u32"],
         "scale_task": ["read_filtered", "~report"], "read_filtered": ["adc_read"],
         "report": ["uart_put_i32", "uart_puts"], "put_hex": ["uart_puts", "~uart_putc"],
         "fib": ["fib"]}

def worst(f, tail_aware=True, path=()):
    if f in path:
        raise RecursionError(" > ".join(path + (f,)))
    best_in, best_tail = 0, 0              # deepest normal callee, deepest tail callee
    for c in CALLS.get(f, []):
        tail = c.startswith("~")
        w = worst(c.lstrip("~"), tail_aware, path + (f,))
        if tail and tail_aware:
            best_tail = max(best_tail, w)  # caller's frame is already gone
        else:
            best_in = max(best_in, w)
    return max(FRAME[f] + best_in, best_tail)

naive, real = worst("main", False), worst("main")
ISR_FRAME = 32 + 4                         # 8 words + possible 4-byte align pad
total = real + ISR_FRAME + worst("SysTick_Handler")
print(f"main, tail call counted as nested: {naive} B")
print(f"main, tail call understood       : {real} B")
print(f"+ SysTick frame {ISR_FRAME} B at the worst moment: {total} B")
try:
    worst("fib")
except RecursionError as e:
    print("fib: recursion, no static bound ->", e)

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

main, tail call counted as nested: 96 B
main, tail call understood       : 88 B
+ SysTick frame 36 B at the worst moment: 124 B
fib: recursion, no static bound -> fib > fib

Tail call বুঝে হিসাব করলে 88 byte, যা board-এর মাপা high-water mark-এর সঙ্গে হুবহু মেলে। Tail call-কে সাধারণ call ধরলে 96: আট byte বেশি, কিন্তু নিরাপদ দিকে ভুল, তাই সরল tool-এর জন্য তা চলে। সবচেয়ে খারাপ মুহূর্তে, অর্থাৎ uart_put_i32-এর ভেতরে SysTick এলে, লাগবে 124 byte. আর fib-এর মতো recursion-এ call graph-এ একটি চক্র; গভীরতা নির্ভর করে চলার সময়ের ইনপুটের ওপর, তাই কোনো স্থির সীমা নেই।

Recursion নিয়ে একটি মজার পর্যবেক্ষণ। একই পরীক্ষা-ফাইলে fact(n) (n * fact(n - 1)) আর fib(n) দুটিই লেখা ছিল। Clang 22 -O2-এ fact-কে পুরো loop বানিয়ে ফেলেছে, assembly-তে নিজেকে আর ডাকে না; কিন্তু fib-এ একটি bl fib রয়ে গেছে। Compiler কখন recursion সরাবে তার নিশ্চয়তা নেই, তাই নিরাপত্তা-জরুরি firmware-এ নিয়মটিই সরল: recursion নয়। MISRA C:2012-এর Rule 17.2 ঠিক এটিই বলে; বিস্তারিত পর্ব ৬৩-এ (নির্ভরযোগ্যতা আর safety — MISRA C, fault tolerance আর functional safety).

Interrupt-এর অংশ নিয়ে একটি সতর্কতা। একই priority-র দুটি interrupt একে অপরকে থামাতে পারে না (Spec decision 19, আর আসল NVIC-এও তাই)। কিন্তু আলাদা priority হলে একটি handler-এর ভেতরে আরেকটি ঢুকতে পারে, প্রত্যেকে নিজের frame নিয়ে। তাই সূত্রে যোগ হয় প্রতিটি আলাদা preemption স্তরের জন্য একটি করে frame আর handler-এর পথ। পাঁচটি interrupt তিনটি priority-তে থাকলে তিনটি স্তর, পাঁচটি নয়।

৫ · মেপে দেখা — stack painting আর high-water mark

হিসাবের পাশে মাপও চাই, কারণ হিসাবের call graph-এ ভুল থাকতে পারে (function pointer, inline assembly, library-র অজানা কোড)। সবচেয়ে প্রচলিত কৌশলের নাম stack painting: boot-এর সময় stack-এর খালি জায়গা একটি চেনা নকশা দিয়ে ভরে রাখা, অনেকক্ষণ চালানো, তারপর নিচ থেকে খুঁজে দেখা কোথায় নকশা প্রথম মুছেছে। সেই বিন্দুই high-water mark, বন্যার পরে দেয়ালে থেকে যাওয়া পানির দাগের মতো।

আমার lab-এর paint.h-এ দুটি ছোট function: stack_paint() (main-এর একেবারে শুরুতে, _ebss থেকে SP − 16 পর্যন্ত 0xC5C5C5C5 লেখে) আর stack_report() (শেষে নিচ থেকে খোঁজে)। Reference lab-এর scale.c-তে শুধু এই দুটি ডাক যোগ করে (scale_hw.c) README-র scale script চালানো হলো। Scale-এর লাইনগুলো reference output-এর সঙ্গে হুবহু এক (৯.৮৩, ৮১.৮৮, ৩২.৭৫ টাকা), শেষে দুটি নতুন লাইন:

সত্যিকারের run — board.py run build/scale_hw.elf --script scale.json
[     2.1495 ms] UART: scale ready: zero=400 counts, span=1400 counts per 2000 g, rate=65.50 Tk/kg
...
[  1102.1809 ms] UART: raw=855 gross=650 g tare=150 g net=500 g price=32.75 Tk
[  1205.2456 ms] UART: paint: SP in main 0x20004FE8, painted words 5105, first touched 0x20004FB4
[  1205.3235 ms] UART: stack: room 20460 B, high-water 76 B, never touched 20384 B
--- coldroom_hw.elf (cold-room script, 20 s) ---
[ 20004.4192 ms] UART: stack: room 20468 B, high-water 76 B, never touched 20392 B
SRAM-এর অবস্থা
ধাপ
SP
রং করা এলাকা
এ পর্যন্ত জানা
  1. Reset. MSP = 0x20005000. Board-এ power-on-এ SRAM পুরোটা শূন্য (Spec decision 18); আসল chip-এ SRAM-এ যা খুশি থাকতে পারে, তাই রং না করে মাপা যায় না।
  2. main-এর শুরু। main-এর frame 24 byte, SP 0x20004FE8. .bss শেষ 0x20000014-এ: scale-এর নিজের 12 byte আর painting-এর দুটি counter-এর 8 byte.
  3. রং করা। 0x20000014 থেকে SP − 16 পর্যন্ত প্রতিটি word-এ 0xC5C5C5C5: (0x20004FD8 − 0x20000014) ÷ 4 = 5105 word, ঠিক যা firmware ছাপল। এই loop-এ board-এ প্রায় 2 ms লেগেছে: “scale ready” লাইন reference-এর 0.0729 ms-এর বদলে 2.1495 ms-এ।
  4. Scale চলছে। ওজন, tare, overload, দাম: পুরো script. সবচেয়ে গভীর ডাক main → uart_put_fixed2 (52 byte), তাই SP নেমেছে 0x20004FE8 − 52 = 0x20004FB4 পর্যন্ত। Firmware নিজে তা জানে না; শুধু দেয়ালে দাগ থেকে যায়।
  5. খোঁজা। stack_report() 0x20000014 থেকে ওপরে উঠছে; যতক্ষণ word = 0xC5C5C5C5, ততক্ষণ সেই জায়গা কখনো ছোঁয়া হয়নি।
  6. ফল। প্রথম অন্য মান 0x20004FB4-এ: high-water mark = 0x20005000 − 0x20004FB4 = 76 byte. কখনো ছোঁয়া হয়নি 20460 − 76 = 20384 byte. অংশ ৪-এর হিসাবেও main 24 + uart_put_fixed2 52 = 76: হিসাব আর মাপ মিলেছে।

এবার সবচেয়ে গুরুত্বপূর্ণ প্রশ্ন: 76 byte কি scale-এর stack-এর সত্যি চাহিদা? না। এই run-এ SysTick প্রতি 1 ms-এ এসেছে, কিন্তু প্রায় সবসময় main তখন __WFI()-এ ঘুমাচ্ছিল (SP 0x20004FE8), তাই ISR-এর frame নেমেছে মাত্র 24 + 32 = 56 byte পর্যন্ত। UART-এ সংখ্যা ছাপার ঠিক মাঝে একটি tick কখনো পড়েনি। কিন্তু পড়তেই পারে: তখন SP 0x20004FB4, যা 8-এর গুণিতক নয়, তাই frame 36 byte, মোট 76 + 36 = 112 byte. মাপা high-water mark বলে “অন্তত এতটা লেগেছিল”, কখনো “এর বেশি লাগবে না” নয়। এ জন্যই পদ্ধতি দুটি: হিসাব দেয় সীমা, মাপ ধরে হিসাবের ভুল।

মাঠের অভ্যাস: High-water mark পরীক্ষার সময়ের একটি কাজ নয়, firmware-এর চিরস্থায়ী অংশও হতে পারে। অনেক RTOS ঠিক এই কৌশলে প্রতিটি task-এর stack-এর ব্যবহার জানায়; যেমন FreeRTOS নতুন task-এর stack 0xA5 দিয়ে ভরে, আর একটি API দিয়ে বাকি কখনো-না-ছোঁয়া জায়গা জানা যায়। Cold-room monitor-এর মতো দীর্ঘ সময় চলা device telemetry-র সঙ্গে নিজের high-water mark পাঠালে মাসের পর মাস মাঠের সত্যিকারের তথ্য জমে। Task-প্রতি stack-এর পুরো আলোচনা পর্ব ৫৬-এ (RTOS-এর task আর scheduling).

৬ · Stack উপচে পড়লে — নীরব ক্ষতি, দেরিতে ধরা আর সঙ্গে সঙ্গে fault

এবার ইচ্ছা করে ভুল। overflow.c-এ scale-এর অবস্থা একটি struct-এ: 4600টি ওজনের ইতিহাস (18400 byte) আর তার ঠিক পরে tare_g = 150. ফলে .bss শেষ হয় 0x200047E8-এ, stack-এর জন্য বাকি 2072 byte, reference linker script-এর 2 KiB সীমার ঠিক ওপরে, তাই link সফল। তারপর একটি recursive function sum_back(n), প্রতিটি স্তরে 40 byte-এর local array; -fstack-usage বলল frame 56 byte. গভীরতা 10, 20, … 60 পর্যন্ত বাড়ানো হলো।

সত্যিকারের run — overflow.elf (কোনো পাহারা নেই)
[     2.1252 ms] UART: stack room: 2072 B, tare_g=150
[     2.3706 ms] UART: depth 10 sum=11 tare_g=150
[     2.8125 ms] UART: depth 20 sum=21 tare_g=150
[     3.4501 ms] UART: depth 30 sum=31 tare_g=150
[     4.2994 ms] UART: depth 40 sum=41 tare_g=134218569
[     5.3444 ms] UART: depth 50 sum=51 tare_g=134218569
[     6.5866 ms] UART: depth 60 sum=61 tare_g=134218569
[     6.5874 ms] exit(0) after 52699 cycles

কোনো fault নেই, কোনো সতর্কবার্তা নেই, যোগফলও ঠিক। শুধু tare হয়ে গেছে 134218569 g, প্রায় ১৩৪ টন! হিসাবটি মেলান: 2072 ÷ 56 = 37, তাই ৩৭তম স্তরের frame ঠিক 0x200047E8-এ শেষ হয়, আর ৩৮তম স্তর .bss-এ ঢোকে। তার frame-এর ওপরের word, যেখানে push {r4, lr} LR রাখে, পড়ে 0x200047E4-এ, ঠিক tare_g-এর ঠিকানায়। আর 134218569 = 0x08000349: flash-এর একটি ঠিকানা, sum_back-এর ভেতরে (map file বলে sum_back 0x080002BC থেকে 0x98 byte), অর্থাৎ recursive bl-এর পরের নির্দেশের ঠিকানা, Thumb বিটসহ। একটি stack overflow সাধারণত ঠিক এভাবেই দেখা দেয়: একটি “অসম্ভব” মানের variable, যার সঙ্গে overflow-এর কোনো দৃশ্যমান সম্পর্ক নেই।

পাহারা বসানো — একটি word যথেষ্ট নয়

প্রথম পাহারা: stack-এর মেঝেতে (_ebss-এ) একটি চেনা মান 0xDEADBEEF রাখা, আর SysTick ISR প্রতি 100 µs-এ পরীক্ষা করবে মানটি আছে কি না; এটি compiler-এর stack canary-র ভাবনার ছোট রূপ। ফল অবাক করার মতো: পাহারা কিছুই ধরেনি, tare আবার নষ্ট। কারণ আবার assembly-তে: sum_back-এর frame push {r4, lr} + sub sp, #48, আর frame-এর সবচেয়ে নিচের word ([sp, #0]) শুধু ৮ byte-এর alignment-এর জন্য রাখা, কখনো লেখা হয় না। ৩৭তম স্তরের ঠিক সেই না-লেখা word-টি পড়েছে 0x200047E8-এ, পাহারাদারের ওপর। Stack তার পাশ দিয়ে নেমে গেছে, ছুঁয়েও দেখেনি।

সমাধান একটি guard band: মেঝের আটটি word (32 byte) পাহারায়। একই firmware, শুধু -DGUARD=8:

সত্যিকারের run — overflow, GUARD=1 বনাম GUARD=8
GUARD=1:  [ 4.3186 ms] UART: depth 40 sum=41 tare_g=134218645   (ধরা পড়েনি)
GUARD=8:  [ 4.3524 ms] UART: STACK OVERFLOW: guard word 1 destroyed, tare_g=134218753
          [ 4.3533 ms] exit(4) after 34826 cycles

এবার ধরা পড়েছে, কিন্তু খেয়াল করুন: ধরার মুহূর্তে tare_g ইতিমধ্যে নষ্ট (এই build-এ ঠিকানা সামান্য সরে যাওয়ায় মানটিও আলাদা)। Canary বা guard band ক্ষতি ধরে, ঠেকায় না; পরীক্ষার ফাঁকে stack আরও নেমে যেতে পারে। এর পরে করণীয়: নষ্ট data ব্যবহার না করে নিরাপদে থামা, ত্রুটির খবর রাখা, আর watchdog দিয়ে reset (পর্ব ৬১, Watchdog আর fault handling).

ঠেকানো — stack-কে SRAM-এর নিচে বসানো

নীরব ক্ষতির মূল কারণ হলো stack-এর নিচে অন্যের data. আমার lab-এর lowstack.ld reference linker script-এর একটি কপি, যেখানে একটি স্থির 2 KiB stack SRAM-এর একেবারে শুরুতে (0x20000000–0x20000800), আর .data/.bss তার ওপরে। এখন stack উপচালে নামবে SRAM-এর বাইরে, যেখানে কোনো memory নেই:

সত্যিকারের run — overflow, lowstack.ld
[     2.1255 ms] UART: stack room: 2048 B, tare_g=150
[     3.4504 ms] UART: depth 30 sum=31 tare_g=150
[     4.1469 ms] HardFault: Invalid memory write (UC_ERR_WRITE_UNMAPPED) at PC=0x080002F8 sum_back+0x34
error: stack overflow while entering exception 3 (SP=0x1FFFFFC8)

প্রথম ভুল লেখাতেই HardFault, tare_g অক্ষত। পরের লাইনটিও শিক্ষণীয়: HardFault-এ ঢুকতে hardware আবার সেই ভাঙা stack-এ frame রাখতে চেয়েছে, আর তা-ও ব্যর্থ। Board তখন থেমে যায় (Spec decision 19: fault-এর ভেতরে fault = lockup). আসল Cortex-M3-এও এমন অবস্থায় সাধারণত lockup হয়, আর বের হওয়ার পথ watchdog বা debugger-এর reset. তবু একটি থেমে যাওয়া যন্ত্র ভুল দামে মাল বেচা যন্ত্রের চেয়ে ভালো। আর HardFault-এর stacked frame থেকে দোষী নির্দেশ খুঁজে বের করার কৌশল পর্ব ৩৮-এ (এমবেডেড debugging). আসল chip-এ SRAM-এর ঠিক নিচের ঠিকানায় লেখা fault দেবে কি না, তা chip-এর memory map দেখে নিশ্চিত হতে হয় (পর্ব ৩১)।

সাবধান — hardware-এর আরও শক্ত পাহারা: Cortex-M3-এর ঐচ্ছিক MPU দিয়ে stack-এর নিচে একটি ছোট “প্রবেশ নিষেধ” অঞ্চল বানানো যায়; stack সেখানে ছুঁলেই সঙ্গে সঙ্গে fault. ARMv8-M-এর core-এ (যেমন Cortex-M33) আছে stack limit register, যা ঠিক এই কাজই করে। কোর্সের board MPU মডেল করে না (Spec decision 19), তাই এখানে run দেখানো গেল না; নিজের chip-এর reference manual দেখে ব্যবহার করুন।

৭ · Heap কেন এড়ানো হয় — fragmentation-এর হিসাব

ধরুন cold-room-এর একটি gateway firmware প্রতিটি বার্তার জন্য malloc করে: telemetry-র JSON (88 byte) আর একটি ছোট status লেখা (32 byte). Telemetry পাঠানো হলে free, status লগে থেকে যায়। ১ KiB-এর একটি heap-এ এর ফল কী? নিচের ব্লক একটি ছোট first-fit allocator চালায়: প্রতিটি block-এর আগে 8 byte-এর header, মাপ 8-এর গুণিতকে গোল, আর free-র সময় পাশাপাশি খালি block জোড়া (coalescing). এটি একটি মডেল, board-এ নয়; heap-এর ভেতরের কাজ C পর্ব ৪৭-এর বিষয়।

# 1 KiB heap, first-fit, 8-byte header per block (like a small malloc)
HEAP, HDR = 1024, 8
heap = [[0, HEAP, None]]                  # [start, size, owner]; None = free

def alloc(n, who):
    need = HDR + (n + 7) // 8 * 8          # header + size rounded to 8
    for i, (s, size, own) in enumerate(heap):
        if own is None and size >= need:   # first free block that fits
            heap[i:i + 1] = [[s, need, who]] + ([[s + need, size - need, None]] if size > need else [])
            return s + HDR
    return None                            # NULL: no single block is big enough

def free(who):
    for b in heap:
        if b[2] == who:
            b[2] = None
    i = 0
    while i < len(heap) - 1:               # join neighbouring free blocks
        if heap[i][2] is None and heap[i + 1][2] is None:
            heap[i][1] += heap.pop(i + 1)[1]
        else:
            i += 1
def show(label):
    free_b = [b[1] for b in heap if b[2] is None]
    bar = "".join(("." if b[2] is None else b[2][0]) * (b[1] // 32) for b in heap)
    print(f"{label:22} free={sum(free_b):4} largest={max(free_b, default=0):4} {bar}")

show("empty")
for k in range(7):                         # cold-room gateway: telemetry + status
    alloc(88, f"T{k}"); alloc(32, f"s{k}")
show("7 x (T 88 B, s 32 B)")
for k in range(7):
    free(f"T{k}")                          # telemetry sent; status kept as a log
show("T freed, s kept")
print("malloc(200) ->", "NULL" if alloc(200, "B") is None else "ok")

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

empty                  free=1024 largest=1024 ................................
7 x (T 88 B, s 32 B)   free=  72 largest=  72 TTTsTTTsTTTsTTTsTTTsTTTsTTTs..
T freed, s kept        free= 744 largest=  96 ...s...s...s...s...s...s...s..
malloc(200) -> NULL

শেষ লাইনটিই heap-এর বিরুদ্ধে মূল অভিযোগ। Heap-এ 744 byte খালি, অথচ 200 byte চাওয়া ব্যর্থ, কারণ খালি জায়গা সাতটি 96 byte-এর টুকরো আর শেষের 72, মাঝে মাঝে status-এর block দাঁড়িয়ে। এর নাম external fragmentation. বারে প্রতিটি অক্ষর মোটামুটি 32 byte (status-এর 40 byte-এর block একটি অক্ষরে)। একটি মাপ প্রায়ই ব্যবহার হয়: 1 − (সবচেয়ে বড় খালি ÷ মোট খালি) = 1 − 96/744 ≈ 0.87; শূন্যের কাছে ভালো, একের কাছে খারাপ।

Heap-এর অবস্থা
কাজ
Heap (১ ঘর ≈ 32 B)
মোট খালি
সবচেয়ে বড় খালি
  1. শুরু। পুরো 1024 byte একটি খালি block. যেকোনো অনুরোধ, 1016 byte পর্যন্ত, মেটানো যায়।
  2. প্রথম জোড়া। malloc(88) নেয় 8 + 88 = 96 byte, malloc(32) নেয় 8 + 32 = 40 byte. প্রতিটি অনুরোধে header-এর 8 byte বাড়তি খরচ।
  3. সাত জোড়া। 7 × 136 = 952 byte ব্যবহৃত, বাকি 72. পরের একটি telemetry (96 byte) আর ধরবে না, তাই gateway এখানেই থামে।
  4. Telemetry পাঠানো, ফেরত। সাতটি 96 byte-এর block খালি হলো, কিন্তু প্রতিটির দুপাশে status-এর block, তাই জোড়া লাগার উপায় নেই। মোট খালি 7 × 96 + 72 = 744 byte, সবচেয়ে বড় টুকরো মাত্র 96.
  5. malloc(200) ব্যর্থ। 744 ≥ 208, তবু NULL: কোনো একটি টানা টুকরো 208 byte (header-সহ) নয়। মাঠের firmware এই NULL ঠিকমতো সামলাতে না পারলে, পরের লেখাতেই ঠিকানা 0x00000008-এ লেখা, অর্থাৎ HardFault বা নীরব ক্ষতি।

Fragmentation ছাড়াও heap-এর আরও তিনটি সমস্যা ছোট firmware-এ গুরুতর। এক, সময়: first-fit খোঁজার সময় নির্ভর করে heap-এর তখনকার অবস্থার ওপর, তাই একটি malloc কত সময় নেবে তার স্থির সীমা বলা কঠিন; real-time কাজে এটি অগ্রহণযোগ্য (WCET, পর্ব ৫৪)। দুই, memory leak: একটি পথে free ভুলে গেলে desktop-এ program বন্ধ করলে সব ফেরত আসে, কিন্তু cold-room monitor-এর মতো বছরের পর বছর না-থামা যন্ত্রে leak একসময় সব খেয়ে ফেলে। তিন, ISR: সাধারণ malloc re-entrant নয়, তাই ISR থেকে ডাকলে heap-এর খাতা নিজেই নষ্ট হতে পারে। এ কারণেই MISRA C:2012-এর Rule 21.3 <stdlib.h>-এর memory allocation আর deallocation function নিষেধ করে, আর বহু দলের নিয়ম আরও নির্দিষ্ট: “শুরুর পরে কোনো dynamic allocation নয়”।

৮ · Static allocation-এর নকশা — pool, ring buffer আর আগে থেকে মাপা জায়গা

Static allocation-এর মূল ভাবনা: প্রতিটি জিনিসের সবচেয়ে বড় দরকার আগেই জেনে নেওয়া, আর সেই মাপের জায়গা compile-এর সময়েই বাঁধা। জায়গা না আঁটলে linker-ই বলবে (অংশ ১-এর ASSERT), মাঠে নয়। চারটি প্রচলিত ধাঁচ:

১. নির্দিষ্ট মাপের global

সবচেয়ে সরল: static char json[128]; একটি telemetry বার্তার জন্য। Scale-এর পুরো firmware এভাবেই চলে, তাই তার .bss মাত্র 12 byte.

২. Memory pool

এক মাপের অনেকগুলো block, একটি free list. নেওয়া আর ফেরত দুটিই O(1), সময় স্থির, আর external fragmentation অসম্ভব, কারণ যেকোনো খালি block যেকোনো অনুরোধে আঁটে।

৩. Ring buffer

ISR থেকে main-এ data পাঠানোর মানক পথ: একটি স্থির array, লেখক আর পাঠকের দুটি index. পুরো তত্ত্ব DSA পর্ব ১৪-এ, UART-এর সঙ্গে বাস্তব রূপ পর্ব ৪৯-এ।

৪. শুধু শুরুতে বরাদ্দ

Library-কে heap দিতেই হলে: boot-এর সময় সব নেওয়া, আর কখনো free নয়। তখন fragmentation হয় না, আর জায়গা না পেলে সমস্যা ধরা পড়ে প্রথম চালুতেই।

অংশ ৭-এর gateway-কে একটি pool দিয়ে লিখলে কী হয়? নিচের C program আটটি 128 byte-এর block-এর একটি pool বানায় (মোট 1 KiB, link-এর সময়েই বাঁধা)। Host-এর compiler-এ চলে, কিন্তু কোডটি board-এ যেমন আছে তেমনই চলবে, কারণ এতে কোনো library-র allocation নেই:

#include <stdio.h>
#include <stdint.h>

#define BLK  128                     /* every block the same size */
#define NBLK 8
static uint8_t pool[NBLK][BLK];      /* 1 KiB, fixed at link time */
static uint8_t *free_list[NBLK];
static int nfree;

static void pool_init(void)
{
    for (int i = 0; i < NBLK; i++)
        free_list[nfree++] = pool[NBLK - 1 - i];
}
static void *pool_get(void) { return nfree ? free_list[--nfree] : NULL; }
static void pool_put(void *p) { free_list[nfree++] = p; }
static int idx(void *p) { return (int)(((uint8_t *)p - &pool[0][0]) / BLK); }

int main(void)
{
    void *t[4], *s[4];
    pool_init();
    for (int k = 0; k < 4; k++) {    /* telemetry 88 B, status 32 B */
        t[k] = pool_get();
        s[k] = pool_get();
    }
    printf("4 pairs: free=%d, one more -> %s\n", nfree, pool_get() ? "ok" : "NULL");
    for (int k = 0; k < 4; k++)
        pool_put(t[k]);              /* telemetry sent */
    printf("T freed: free=%d, status in blocks %d %d %d %d\n",
           nfree, idx(s[0]), idx(s[1]), idx(s[2]), idx(s[3]));
    printf("120 B batch -> block %d; waste in a status block: %d of %d B\n",
           idx(pool_get()), BLK - 32, BLK);
    return 0;
}

আসল আউটপুট (Wandbox-এর C compiler):

4 pairs: free=0, one more -> NULL
T freed: free=4, status in blocks 1 3 5 7
120 B batch -> block 6; waste in a status block: 96 of 128 B

Status-এর block-গুলো 1, 3, 5, 7 নম্বরে, অংশ ৭-এর heap-এর মতোই মাঝে মাঝে ছড়ানো। তবু 120 byte-এর batch buffer সঙ্গে সঙ্গে block 6 পেয়েছে, কারণ pool-এ “বড় টানা জায়গা” বলে কিছু চাইতে হয় না। দামও স্পষ্ট: 32 byte-এর status-এর জন্য পুরো 128 byte-এর block, ভেতরে 96 byte নষ্ট। এটি internal fragmentation, কিন্তু তার মাপ আগে থেকেই জানা আর বাড়ে না। আসল নকশায় তাই সাধারণত দুটি pool, ছোট আর বড়। আর ISR আর main দুজনেই pool ব্যবহার করলে pool_get/pool_put-কে critical section-এ রাখতে হয় (পর্ব ৪৩)।

শেষে stack-এর নিজের static নকশা। ISR-এর ভেতরে বড় local array (যেমন char json[512]) প্রতিটি preemption স্তরে stack-এর চাহিদা সরাসরি বাড়ায়; একই buffer static করলে সেটি একবারই, .bss-এ, map file-এ দৃশ্যমান। Recursion-এর বদলে loop, বা দরকার হলে স্থির মাপের নিজস্ব array-কে stack হিসেবে ব্যবহার। আর linker script-এ stack-এর জন্য একটি স্পষ্ট মাপ (অংশ ৬-এর lowstack.ld-এর মতো), যাতে .bss বাড়লে link ব্যর্থ হয়, stack নীরবে ছোট না হয়। RTOS এলে প্রতিটি task-এর নিজের stack লাগে; তখন এই সব হিসাব task-প্রতি করতে হয় (পর্ব ৫৬)।

আরও গভীরে: ARM-এর AAPCS নিয়মে public function-এর সীমানায় SP 8-এর গুণিতক থাকতে হয়, কিন্তু function-এর ভেতরে তা না-ও থাকতে পারে (uart_put_fixed2-এর 52 byte-এর frame তার উদাহরণ)। Interrupt এর মাঝে আসতে পারে বলে Cortex-M exception entry-তে hardware নিজেই SP 8-এ মেলায়: CCR-এর STKALIGN বিট, যা Cortex-M3-এর পরের revision-গুলোতে reset-এ চালু, আর ARMv7-M-এর অন্য core-এ সবসময়। -fstack-usage শুধু function-এর নিজের frame দেয়; পুরো চিত্রের জন্য call graph লাগে, আর function pointer (যেমন callback-এর টেবিল) থাকলে কে কাকে ডাকে তা আর স্থির থাকে না। বাণিজ্যিক static stack analyzer-গুলো তাই binary-র machine code থেকেই call graph বানায়, আর অজানা লাফের জন্য মানুষের দেওয়া টীকা চায়।

পরীক্ষা ও ইন্টারভিউতে: “এমবেডেড-এ malloc কেন এড়ানো হয়?” → fragmentation, অনির্দিষ্ট সময়, leak, ISR-এ অনিরাপদ, আর ব্যর্থতা মাঠে ধরা পড়ে। “Stack-এর আকার কীভাবে ঠিক করবেন?” → frame-এর মাপ (-fstack-usage) + call graph-এর সবচেয়ে গভীর পথ + প্রতিটি preemption স্তরে interrupt frame, তারপর painting দিয়ে মেপে মার্জিন। “Cortex-M3-এ interrupt frame কত বড়?” → 8 word = 32 byte, SP 8-এর গুণিতক না হলে 36. “Stack overflow কীভাবে ধরবেন?” → painting, guard band, MPU guard region, ARMv8-M-এ stack limit register. “Tail call stack-এ কী করে?” → caller-এর frame আগেই ফেরত যায়, তাই গভীরতা বাড়ে না।

৯ · AI-এর যুগে embedded memory যাচাই

AI assistant memory-র প্রশ্নে প্রায়ই সাধারণ desktop-এর অভ্যাস নিয়ে আসে, আর সংখ্যা দেয় আত্মবিশ্বাসের সঙ্গে, যাচাই ছাড়া। কয়েকটি পরিচিত ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
Firmware-এ, এমনকি ISR-এ, malloc দিয়ে buffer বানায়Map file-এ heap আছে কি না দেখা; pool বা static buffer চাওয়া; ISR-এ কোনো allocation নয় (পর্ব ৪৩)
“Stack 1 KiB দিলেই যথেষ্ট” ধাঁচের অনুমান দেয়-fstack-usage + call graph-এর হিসাব, তারপর board বা simulator-এ painting
Interrupt frame সবসময় 32 byte বলে, alignment-এর ফাঁকা word আর FPU-র বড় frame ভুলে যায়Architecture reference manual; board-এ ISR-এর ভেতরে SP আর stacked xPSR-এর বিট ৯ পড়া
“Clang-এ -fstack-usage নেই” বা ভুল option-এর নাম বলেনিজের toolchain-এ একবার চালিয়ে দেখা; এই পর্বে Clang 22.1.8-এ কাজ করেছে
সহজ সমাধান হিসেবে recursion লেখে (tree, parser, menu)Call graph-এ চক্র খোঁজা; loop বা স্থির মাপের নিজস্ব stack-এ রূপান্তর
একটি word-এর canary দিয়েই overflow ধরার কথা বলেGuard band (কয়েক word), MPU বা stack-কে SRAM-এর নিচে বসানো; overflow ইচ্ছা করে ঘটিয়ে পাহারা পরীক্ষা

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

আমি ARM Cortex-M3-এর জন্য bare-metal firmware লিখছি (Clang, -O2, -ffreestanding, OS নেই, 20 KiB SRAM, heap নেই)। ১. নিচের -fstack-usage ফাইল আর call graph থেকে main-এর সবচেয়ে খারাপ stack বের করো। কোন call tail call, তা আলাদা করে ধরবে, আর প্রতিটি যোগফল লিখে দেখাবে। ২. দুটি interrupt priority 1 আর একটি priority 3-এ থাকলে interrupt-এর জন্য কতটা যোগ হবে? প্রতিটি frame-এ alignment-এর 4 byte ধরবে কি না, কারণসহ বলো। ৩. malloc ছাড়া cold-room telemetry-র বার্তার জন্য একটি fixed-size pool লেখো, ISR আর main দুজনের ব্যবহারে নিরাপদ। ৪. কোনো সংখ্যা বা register-এর নাম অনুমান করলে "অনুমান" লিখবে, আর উৎস (ARMv7-M manual, compiler documentation) বলবে।

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

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

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

প্র ০১নিরাপত্তা-জরুরি firmware-এর নিয়মগুলো কেন বারবার বলে “dynamic memory নয়”? এই নিষেধ কোথা থেকে এল, আর এর মধ্যে কোন সূক্ষ্মতা হারিয়ে যায়?

দুটি পরিচিত উৎস আছে। প্রথমটি MISRA C, গাড়ি শিল্প থেকে আসা C-র নিয়মের সংকলন, যার প্রথম সংস্করণ ১৯৯৮ সালে। এর ২০১২ সালের সংস্করণে Rule 21.3 সরাসরি বলে, <stdlib.h>-এর memory allocation আর deallocation function ব্যবহার করা যাবে না, আর একটি directive সাধারণভাবেই dynamic allocation নিষেধ করে। দ্বিতীয়টি NASA-র Jet Propulsion Laboratory-র Gerard Holzmann-এর “The Power of Ten” (২০০৬), নিরাপত্তা-জরুরি কোডের দশটি নিয়ম। তার তৃতীয় নিয়ম: শুরুর (initialization) পরে কোনো dynamic memory allocation নয়। প্রথম নিয়মে recursion-ও নিষেধ, যাতে stack-এর সীমা প্রমাণ করা যায়।

যুক্তিগুলো এই পর্বেই দেখেছেন। Heap-এর ব্যর্থতা নির্ভর করে অনুরোধের ক্রম আর মাপের ওপর: ১ KiB-এর heap-এ 744 byte খালি থাকতেও 200 byte পাওয়া যায়নি। কোন ক্রমে অনুরোধ আসবে, তা মাঠের ঘটনার ওপর নির্ভর করে, পরীক্ষায় সব ক্রম ধরা অসম্ভব। malloc-এর সময়ও অবস্থাভেদে বদলায়, তাই real-time প্রমাণে বসানো কঠিন। আর free ভুলে যাওয়া, দুবার free, বা ফেরত দেওয়া জায়গা পরে ব্যবহার: C-র এই পুরোনো ভুলগুলো firmware-এ মানে যন্ত্রের অনির্দিষ্ট আচরণ।

তবে নিয়মগুলো পড়ার সময় একটি সূক্ষ্মতা হারিয়ে যায়। Holzmann-এর নিয়ম “শুরুর পরে” বলে, “কখনো নয়” বলে না। Boot-এর সময় একবার সব নিয়ে নেওয়া, আর কখনো ফেরত না দেওয়া কার্যত static allocation-ই: fragmentation হয় না, ব্যর্থতা ধরা পড়ে প্রথম চালুতেই। Pool allocator-ও আসলে একটি dynamic allocator, কিন্তু এক মাপের block হওয়ায় external fragmentation অসম্ভব আর সময় স্থির। তাই আধুনিক RTOS-গুলো সাধারণত দুই রকম API-ই দেয়: heap থেকে বানানো task আর আপনার দেওয়া static জায়গায় বানানো task. সমস্যা “dynamic” শব্দে নয়, অনির্দিষ্টতায়।

এর সঙ্গে আরেকটি বাস্তবতা: নিয়ম মানা মানে কাজ বেশি। প্রতিটি buffer-এর সবচেয়ে বড় মাপ আগে থেকে জানতে হয়, যা নকশার শুরুতেই প্রশ্নগুলো জিজ্ঞেস করতে বাধ্য করে। বাজারঘরের cold room-এ সবচেয়ে বড় telemetry বার্তা কত byte, কতগুলো একসঙ্গে জমতে পারে, network বন্ধ থাকলে কী হবে। এই প্রশ্নগুলো heap-এর আড়ালে চাপা পড়ে থাকে, আর মাঠে গিয়ে উত্তর দেয়।

মূল উপলব্ধি: নিষেধের আসল লক্ষ্য অনির্দিষ্টতা দূর করা; শুরুতে একবার বরাদ্দ আর এক মাপের pool সেই লক্ষ্য মানে, এলোমেলো malloc/free মানে না।

প্র ০২Stack painting-এ scale-এর high-water mark 76 byte এল। একজন সহকর্মী বললেন, “তাহলে stack 128 byte দিলেই চলবে।” তাঁর যুক্তির শক্তি আর দুর্বলতা কী?

শক্তির দিক আগে। Painting একটি আসল মাপ, অনুমান নয়: board-এ পুরো scale script, অর্থাৎ ওজন, tare, overload আর দাম, চালিয়ে দেখা গেছে stack 76 byte-এর বেশি নামেনি, আর হিসাবও (main 24 + uart_put_fixed2 52) ঠিক এটাই বলে। 128 byte তার প্রায় দেড় গুণ। ছোট chip-এ, যেমন 2 KiB SRAM-এর ATmega328P-এ, এমন হিসাবি মাপ অনেক সময় বাঁচিয়ে দেয়।

দুর্বলতা তিনটি। প্রথমত, মাপা ফল শুধু সেই run-এর সত্য। এই run-এ SysTick প্রায় সবসময় এসেছে যখন main ঘুমাচ্ছিল; সংখ্যা ছাপার মাঝে কখনো আসেনি। এলে লাগবে 76 + 36 = 112 byte, আর পরে কেউ UART-এর interrupt বা আরেকটি priority যোগ করলে আরও বেশি। Real-time জগতে WCET-এর ক্ষেত্রেও একই শিক্ষা: পরীক্ষায় দেখা সবচেয়ে বেশি সময় সবচেয়ে খারাপ সময় নয়। দ্বিতীয়ত, coverage: script-এ যে পথ চলেনি (ধরুন, একটি ভুলের বার্তা ছাপার পথ, যেখানে বড় buffer আছে), তার stack মাপা হয়নি। তৃতীয়ত, firmware বদলায়: compiler-এর নতুন version, অন্য optimization flag বা একটি নতুন function frame-এর মাপ বদলে দেয়; এই পর্বেই -O0-এ একই কোডের high-water mark 88 থেকে 220 হয়েছে।

ভালো পদ্ধতি তাই তিন স্তরের। প্রথমে হিসাব: -fstack-usage আর call graph থেকে সবচেয়ে খারাপ পথ, interrupt-এর প্রতিটি preemption স্তরসহ; এটি সীমা দেয়। তারপর মাপ: দীর্ঘ, বৈচিত্র্যময় পরীক্ষায় painting, যা হিসাবের ভুল (অজানা call, inline assembly) ধরে। মাপ হিসাবের চেয়ে বেশি এলে হিসাবটাই ভুল, খুঁজতে হবে কেন। শেষে মার্জিন, যার মাপ ঝুঁকির ওপর নির্ভর করে; অনেক দল নিজের নিয়ম লিখে রাখে, আর build-এ সেটি পরীক্ষা করে। সঙ্গে পাহারা: guard band বা MPU, যাতে সব হিসাব ভুল হলেও নীরব ক্ষতি না হয়।

সহকর্মীর 128 byte তাই হয়তো ঠিক সংখ্যাই, কিন্তু ভুল কারণে। 112-এর হিসাব জানার পরে 128 বেছে নেওয়া একটি সিদ্ধান্ত; 76 দেখে 128 বলা একটি আশা।

মূল উপলব্ধি: High-water mark বলে “অন্তত এতটা লেগেছিল”; সীমা আসে হিসাব থেকে, আর নিরাপত্তা আসে মার্জিন আর পাহারা থেকে।

প্র ০৩প্রায় সব firmware-এ stack SRAM-এর ওপরে বসে নিচে নামে, আর data নিচে। এই প্রথা কোথা থেকে এল, আর stack-কে নিচে বসানো কি সবসময় ভালো?

প্রথাটি পুরোনো। এই কোর্সের 8085-এ PUSH SP কমিয়ে লেখে (পর্ব ১২), 8086-এও তাই। Unix-এর প্রথম দিকের মেমরি সাজানোয় program আর data নিচে, তার ওপরে heap ওপরের দিকে বাড়ত, আর stack সবার ওপরে থেকে নিচের দিকে নামত। দুজনের মাঝে একটি বড় ফাঁকা অংশ, যা দুপক্ষই প্রয়োজনমতো ব্যবহার করে। কে কতটা নেবে, আগে থেকে জানতে হয় না: এই নমনীয়তাই প্রথার মূল সুবিধা। ARM-এর AAPCS-ও “full descending” stack ঠিক করে দিয়েছে, আর Cortex-M-এর reset-এ MSP আসে vector table-এর প্রথম word থেকে, সাধারণত SRAM-এর শেষ ঠিকানা।

কিন্তু এই নমনীয়তার দাম এই পর্বে দেখা গেছে। Stack উপচালে প্রথমে যা পায় তা অন্যের data: .bss-এর tare_g, যেখানে একটি return address বসে tare হলো 134218569 g. কোনো fault নেই, কারণ hardware-এর চোখে এটি একটি বৈধ SRAM-এ বৈধ লেখা। Heap থাকলে অবস্থা আরও খারাপ: দুজনের দেখা হওয়ার বিন্দু বদলায় চলার সময়, আর কে কার ওপর লিখল, তা খুঁজে বের করা প্রায় গোয়েন্দার কাজ।

Stack-কে SRAM-এর একেবারে নিচে বসালে (আমার lab-এর lowstack.ld) overflow নামে SRAM-এর বাইরে। Board-এ প্রথম ভুল লেখাতেই HardFault হয়েছে, tare_g অক্ষত। এর দাম দুটি। এক, stack-এর মাপ এখন স্থির: linker script-এ লিখে দিতে হয়, আর হিসাব ভুল হলে stack আর ফাঁকা জায়গা ধার নিতে পারে না; অর্থাৎ অংশ ৪-এর হিসাব বাধ্যতামূলক হয়। দুই, SRAM-এর নিচের ঠিকানায় লেখা আসলেই fault দেবে কি না, তা chip-এর memory map-এর ওপর নির্ভর করে। আর fault হলেও HardFault handler নিজে চালাতে stack লাগে, যা তখন ভাঙা; board-এ আর সাধারণত আসল Cortex-M3-এ এটি lockup-এ গড়ায়।

আধুনিক উত্তর তাই hardware-এর সাহায্য: MPU দিয়ে stack-এর নিচে একটি নিষিদ্ধ অঞ্চল, বা ARMv8-M-এর stack limit register, যা SP সীমা পেরোনোর আগেই fault তোলে। তখন stack ওপরে বসলেও overflow নীরব থাকে না। কোনো একটি সাজানো সবসময় ভালো নয়; প্রশ্নটি হলো, ভুল হলে আপনি কোনটি চান: নীরব ভুল দাম, নাকি থেমে যাওয়া যন্ত্র আর watchdog-এর reset.

মূল উপলব্ধি: Stack-এর জায়গা ঠিক করা আসলে ব্যর্থতার ধরন বেছে নেওয়া; নীরব data-নষ্টের বদলে দ্রুত, দৃশ্যমান fault প্রায় সবসময় ভালো বিনিময়।

প্র ০৪Clang fact(n)-এর recursion নিজে থেকেই loop বানিয়ে দিল, কিন্তু fib(n)-এর নয়। তাহলে কি recursion-এর নিষেধ পুরোনো হয়ে গেছে?

না, আর এই পরীক্ষাই তার প্রমাণ। fact-এর রূপ n * fact(n - 1): শেষ কাজটি গুণ, call নয়, তাই এটি আক্ষরিক tail call নয়। তবু optimizer বুঝেছে, একটি জমা-রাখা গুণফল (accumulator) দিয়ে এটি loop-এ লেখা যায়, আর লিখেছে: assembly-তে কোনো bl fact নেই, stack-এর গভীরতা স্থির। fib-এ দুটি call-এর ফল যোগ হয়; একটিকে loop বানানো গেছে, কিন্তু অন্যটি bl fib হয়ে রয়ে গেছে, তাই stack-এর গভীরতা এখনো n-এর সমানুপাতিক।

সমস্যা হলো, কোন রূপ optimizer সামলাবে তার কোনো নিশ্চয়তা C standard দেয় না। একই কোড -O0-এ, অন্য compiler-এ বা ছোট একটি বদলের পরে (ধরুন, function-এ একটি debug print যোগ করা) আবার সত্যিকারের recursion হয়ে যেতে পারে। নিরাপত্তা-জরুরি কোডের নিয়ম তাই compiler-এর দয়ার ওপর নির্ভর করে না: MISRA C:2012-এর Rule 17.2 বলে, function প্রত্যক্ষ বা পরোক্ষভাবে নিজেকে ডাকবে না; Holzmann-এর “Power of Ten”-এর প্রথম নিয়মেও recursion বাদ। উদ্দেশ্য একটাই: call graph যেন চক্রহীন থাকে, যাতে অংশ ৪-এর মতো একটি tool সবচেয়ে খারাপ stack প্রমাণ করতে পারে।

Recursion-এর গভীরতা কখনো কখনো সীমিত, যেমন একটি সুষম tree-তে log n. তখনও হিসাবের জন্য সেই সীমা প্রমাণ করতে হয়, আর ইনপুট যদি বাইরে থেকে আসে (ধরুন, একটি JSON parser, যাকে MQTT-তে কেউ গভীরভাবে nested বার্তা পাঠাল), তাহলে সীমাটি আক্রমণকারীর হাতে। এ জন্য নিরাপদ parser-গুলো nesting-এর একটি স্পষ্ট সীমা রাখে।

বাস্তব সমাধান সাধারণত সরল: recursion-কে loop-এ রূপান্তর, আর দরকার হলে একটি স্থির মাপের নিজস্ব array-কে stack হিসেবে ব্যবহার, যার উপচে পড়া আপনি নিজে পরীক্ষা করে নিরাপদে সামলাতে পারেন (“nesting too deep” বলে বার্তা বাতিল)। এতে stack-এর হিসাব আবার স্থির হয়, আর সীমা হয় একটি সংখ্যা, যা map file-এ দেখা যায়।

মূল উপলব্ধি: Optimizer কখনো কখনো recursion সরায়, কিন্তু নিশ্চয়তা দেয় না; চক্রহীন call graph-ই stack-এর প্রমাণযোগ্য সীমার পূর্বশর্ত।

প্র ০৫Cold-room monitor-এ পরে একটি RTOS আসবে, চারটি task নিয়ে। Memory-র হিসাব কীভাবে বদলাবে, আর interrupt-এর frame কার stack-এ পড়বে?

Super loop-এ stack একটি, তাই হিসাবও একটি: main-এর সবচেয়ে খারাপ পথ আর interrupt-এর স্তরগুলো। RTOS এলে প্রতিটি task নিজের আলাদা stack পায়, কারণ একটি task থামলে তার পুরো অবস্থা (local, register, ফেরার ঠিকানা) তার নিজের stack-এ জমা থাকে, যতক্ষণ না আবার চলার পালা আসে। চারটি task মানে চারটি stack, প্রতিটির জন্য অংশ ৪-এর হিসাব আলাদা করে, আর মোট SRAM-এর বাজেটে চারটির যোগফল। প্রতিটির মার্জিনও আলাদা যোগ হয়, তাই RTOS-এ stack-এর মোট খরচ দ্রুত বাড়ে; ২ বা ২০ KiB-এর chip-এ এটিই প্রায়ই সবচেয়ে বড় খাত।

Interrupt-এর প্রশ্নটি Cortex-M-এর একটি সুন্দর নকশায় জড়িত। Cortex-M-এর দুটি stack pointer: MSP আর PSP. সাধারণ RTOS-এ task-গুলো চলে PSP-তে, আর handler সবসময় MSP-তে (পর্ব ৩০)। Interrupt এলে hardware আটটি word-এর frame রাখে চলতি stack-এ, অর্থাৎ যে task তখন চলছিল তার PSP-তে; তারপর handler-এর নিজের frame আর nested interrupt-গুলো যায় MSP-তে। ফলে প্রতিটি task-এর stack-এ একটি interrupt frame-এর জায়গা রাখতে হয় (FPU থাকলে বড়টি), কিন্তু nested handler-দের পুরো খরচ শুধু একবার, MSP-তে। Super loop-এর তুলনায় এটি বড় সাশ্রয়: চারটি task-এর প্রত্যেকে সব interrupt-এর সবচেয়ে খারাপ গভীরতা বহন করে না।

মাপার দিকেও RTOS সাহায্য করে। FreeRTOS-এর মতো kernel নতুন task-এর stack একটি নকশা (0xA5) দিয়ে ভরে, অর্থাৎ এই পর্বের stack painting-ই, আর একটি API দিয়ে প্রতিটি task-এর কখনো-না-ছোঁয়া অংশ জানায়। Context switch-এর সময় stack-এর শেষ অংশ পরীক্ষা করার ঐচ্ছিক ব্যবস্থাও থাকে, যা guard band-এর ভাবনা। তবে অংশ ৬-এর শিক্ষা এখানেও খাটে: এগুলো ক্ষতি ধরে, ঠেকায় না; MPU-সহ port থাকলে task-এর stack-এর সীমা hardware দিয়েও পাহারা দেওয়া যায়।

বাজেটের টেবিল তাই বদলায়: static data, প্রতিটি task-এর stack (frame-এর হিসাব + একটি interrupt frame + মার্জিন), MSP-র stack (startup, আর nested handler-দের সবচেয়ে খারাপ পথ), আর RTOS-এর নিজের খাতা (প্রতিটি task-এর control block, queue). RTOS-এর scheduling আর task-এর বিস্তারিত পর্ব ৫৬-এ।

মূল উপলব্ধি: RTOS-এ stack-এর হিসাব task-প্রতি; Cortex-M-এর MSP/PSP ভাগের কারণে প্রতিটি task-এ একটি interrupt frame, আর nested handler-দের খরচ শুধু MSP-তে একবার।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — telemetry-র pool, ISR-নিরাপদ: Cold-room monitor-এর UART ISR আর main দুজনেই 96 byte-এর বার্তার block নেয় আর ফেরত দেয়। Heap ছাড়া, একক-core Cortex-M3-এ নিরাপদ একটি pool লিখুন: block-এর সংখ্যা ৬টি, block না থাকলে NULL, আর মোট মাপ link-এর সময়েই জানা।
    #define MSG_BLK  96u
    #define MSG_N    6u
    static uint8_t  msg_pool[MSG_N][MSG_BLK];   /* 576 B, .bss-এ, map file-এ দেখা যায় */
    static uint8_t *msg_free[MSG_N];
    static uint32_t msg_nfree;
    
    void msg_init(void)                          /* boot-এ একবার */
    {
        for (uint32_t i = 0; i < MSG_N; i++)
            msg_free[msg_nfree++] = msg_pool[i];
    }
    void *msg_get(void)
    {
        void *p = NULL;
        uint32_t pm = __get_PRIMASK();           /* ISR থেকেও ডাকা যায় */
        __disable_irq();
        if (msg_nfree) p = msg_free[--msg_nfree];
        __set_PRIMASK(pm);                       /* আগের অবস্থা ফেরত */
        return p;
    }
    void msg_put(void *p)
    {
        uint32_t pm = __get_PRIMASK();
        __disable_irq();
        msg_free[msg_nfree++] = p;
        __set_PRIMASK(pm);
    }

    মূল সিদ্ধান্তগুলো: (১) সব জায়গা static, তাই 6 × 96 = 576 byte map file-এর .bss-এ দেখা যায়, আর না আঁটলে link ব্যর্থ। (২) msg_nfree-এর read-modify-write main আর ISR দুজনেই করে, তাই critical section; শুধু volatile যথেষ্ট নয় (পর্ব ৩৪)। (৩) __enable_irq()-এর বদলে আগের PRIMASK ফেরত দেওয়া, যাতে ISR-এর ভেতর থেকে, বা interrupt আগে থেকেই বন্ধ থাকা অবস্থায় ডাকলেও ভুল করে interrupt চালু না হয়। (৪) Critical section কয়েকটি নির্দেশের, তাই interrupt latency প্রায় বাড়ে না। CMSIS-এ __get_PRIMASK/__set_PRIMASK নামের helper থাকে; কোর্সের bazarghar.h-এ নেই, তাই আমার lab-এর msgpool.c-তে দুই লাইনের inline assembly (mrs/msr primask) লেখা হলো। Board-এ main ২০০০ বার ছয়টি block নিল আর ফেরত দিল, আর প্রতি 100 cycle-এ SysTick ISR একটি নিয়ে ফেরত দিল। Map file-এ msg_pool 0x240 = 576 byte, আর ফল: main got 12000 null 0, isr ok 1428 null 286, free at end 6. ISR-এর ২৮৬টি NULL ঠিক সেই মুহূর্তগুলোর, যখন main ছয়টিই ধরে ছিল; শেষে ছয়টি block-ই ফেরত, একটিও হারায়নি বা দুজনকে দেওয়া হয়নি।

  2. ভুল খুঁজুন — একটি firmware-এর memory-র তিনটি ভুল: নিচের Cortex-M3 কোডে memory-সংক্রান্ত তিনটি ভুল খুঁজুন, প্রতিটির ফল বলুন।
    extern uint32_t _ebss;
    void UART_IRQHandler(void)
    {
        char json[512];                          /* বার্তা সাজানো */
        char *copy = malloc(strlen(rx_line) + 1);
        strcpy(copy, rx_line);
        ...
    }
    void SysTick_Handler(void)                   /* overflow পাহারা */
    {
        if (_ebss != 0xDEADBEEFu) panic();       /* একটি word */
    }

    (১) ISR-এর ভেতরে char json[512]: প্রতিবার UART interrupt-এ stack 512 byte-এর বেশি নামে, আর এটি main-এর সবচেয়ে গভীর পথের ওপরে যোগ হয়। SysTick যদি UART-কে বা UART যদি অন্য কাউকে preempt করতে পারে, যোগ হয় আরও। সমাধান: static char json[512]; (একবারই, .bss-এ, map file-এ দৃশ্যমান), বা ISR-এ শুধু byte জমিয়ে সাজানোর কাজ main-এ। (২) ISR-এ malloc: সাধারণ malloc re-entrant নয়, main-এর malloc-এর মাঝখানে ISR এলে heap-এর খাতা নষ্ট হতে পারে; NULL যাচাই নেই, তাই heap ভরা থাকলে strcpy ঠিকানা 0-তে লিখবে। আর কোর্সের board-এ malloc link-ই হয় না (undefined symbol: malloc). সমাধান: একটি static pool (অনুশীলন ১) বা নির্দিষ্ট মাপের line buffer. (৩) একটি word-এর পাহারা: এই পর্বের board run-এ ঠিক এমন পাহারা overflow ধরেনি, কারণ একটি frame-এর alignment-এর জন্য রাখা না-লেখা word পাহারার ওপর পড়েছিল, আর stack তার পাশ দিয়ে নেমে tare_g নষ্ট করেছে। আট word-এর guard band একই overflow ধরেছে (“guard word 1 destroyed”). তার ওপর, পাহারা ধরে, ঠেকায় না; stack-কে SRAM-এর নিচে বসানো বা MPU দিয়ে সঙ্গে সঙ্গে fault আরও নিরাপদ।

  3. হিসাব — সবচেয়ে খারাপ stack: একটি firmware-এর -fstack-usage: main 24, task_a 40, fmt 40, task_b 16, send 72, crc 8 byte. Call: main → task_a → fmt; main → task_b, আর task_b-এর শেষ কাজ send (tail call); send → crc. Interrupt: SysTick (priority 3, handler 16 byte), EXTI0 (priority 1, 24 byte), UART (priority 1, 32 byte). প্রতিটি interrupt frame 36 byte ধরে main-এর সবচেয়ে খারাপ পথ, interrupt-এর অংশ আর মোট stack বের করুন। Tail call-কে সাধারণ call ধরলে main-এর অংশ কত হতো? 25% মার্জিনসহ কত রাখবেন?

    Main-এর পথ. task_a পথ: 24 + 40 + 40 = 104. task_b পথ: tail call-এ task_b-এর 16 byte send শুরুর আগেই ফেরত যায়, তাই send চলে main-এর ঠিক নিচে: 24 + 72 + 8 = 104. সবচেয়ে খারাপ = 104 byte. Tail call-কে সাধারণ call ধরলে task_b পথ 24 + 16 + 72 + 8 = 120, অর্থাৎ 16 byte বেশি (নিরাপদ দিকে ভুল)।

    Interrupt. Priority 3 (SysTick) থামাতে পারে priority 1-এর একজন; EXTI0 আর UART একই priority, একে অপরকে থামাতে পারে না। তাই দুটি স্তর: SysTick 36 + 16 = 52, তার ভেতরে priority 1-এর বড়টি (UART) 36 + 32 = 68. Interrupt-এর অংশ 52 + 68 = 120 byte.

    মোট. 104 + 120 = 224 byte; 25% মার্জিনে 224 × 1.25 = 280 byte. হিসাবটি আমার lab-এর অংশ ৪-এর মতো estimator-এ চালিয়ে মেলানো: main worst 104 naive 120 isr chain 120 total 224 x1.25 -> 280.0. খেয়াল করুন, interrupt-এর অংশ main-এর অংশের সমান: ছোট firmware-এ stack-এর বড় খরচ প্রায়ই interrupt থেকেই আসে।

  4. আগে বলুন, তারপর মিলিয়ে দেখুন — 256 byte-এর heap: First-fit, প্রতিটি block-এ 8 byte header, মাপ 8-এর গুণিতকে গোল, free-তে পাশের খালি block জোড়া। ক্রম: A = malloc(40), B = malloc(24), C = malloc(40), D = malloc(24), তারপর free(A), free(C), তারপর E = malloc(56), F = malloc(60). প্রতিটি ফেরত ঠিকানা (heap-এর শুরু থেকে offset), F-এর ফল, আর শেষে মোট খালি ও সবচেয়ে বড় খালি block কত?

    A নেয় 8 + 40 = 48 byte (0–47), ফেরত offset 8; B নেয় 8 + 24 = 32 (48–79), ফেরত 56; C 48 byte (80–127), ফেরত 88; D 32 byte (128–159), ফেরত 136. বাকি 160–255, 96 byte. free(A) আর free(C): দুটি 48 byte-এর খালি block, কিন্তু মাঝে B, তাই জোড়া লাগে না। E-এর দরকার 8 + 56 = 64: প্রথম দুটি 48-এর খালি block-এ আঁটে না, তাই শেষের 96 byte-এর block থেকে, ফেরত offset 168, বাকি 32 byte. F-এর দরকার 8 + 64 = 72 (60 গোল হয়ে 64): খালি block 48, 48, 32, কোনোটিতেই আঁটে না, তাই NULL, যদিও মোট খালি 128 byte. সবচেয়ে বড় খালি 48. অংশ ৭-এর মডেলের মতো একটি allocator-এ চালিয়ে ঠিক এই ফল: A 8, B 56, C 88, D 136, E(56) -> 168, F(60) -> None, free 128 largest 48.

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

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

ক্রমএকটি Cortex-M firmware-এর stack-এর আকার প্রমাণসহ ঠিক করার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Release flag-এ -fstack-usage দিয়ে build করে প্রতিটি function-এর frame জানা
  2. Call graph থেকে main-এর সবচেয়ে গভীর পথ বের করা, recursion থাকলে আগে সরানো
  3. প্রতিটি preemption স্তরের জন্য interrupt frame আর handler-এর পথ যোগ করা
  4. মার্জিন যোগ করে linker script-এ stack-এর মাপ বসানো
  5. Stack painting দিয়ে দীর্ঘ পরীক্ষায় high-water mark মেপে হিসাবের সঙ্গে মেলানো

একটি Cortex-M3-এ interrupt নেওয়ার সময় hardware চলতি stack-এ কত byte রাখে (FPU নেই)?

  • 8 byte: PC আর xPSR
  • 32 byte, SP 8-এর গুণিতক না হলে 36
  • 64 byte: R0–R15 সব
  • Handler-এর local variable-এর মাপের ওপর নির্ভর করে

একটি firmware-এ stack painting করে দীর্ঘ পরীক্ষার পরে high-water mark এল 76 byte. এর সঠিক অর্থ কী?

  • Firmware কখনো 76 byte-এর বেশি stack ব্যবহার করবে না
  • Stack-এ 76 byte খালি রয়ে গেছে
  • পরীক্ষার সময় stack অন্তত 76 byte পর্যন্ত নেমেছিল; সবচেয়ে খারাপ সীমা এর বেশি হতে পারে
  • Debug build-এ stack 76 byte-এ সীমিত

১ KiB-এর একটি heap-এ মোট 744 byte খালি, তবু malloc(200) NULL ফেরত দিল (header 8 byte). সবচেয়ে সম্ভাব্য কারণ কী?

  • External fragmentation: কোনো একটি টানা খালি টুকরো 208 byte নয়
  • Internal fragmentation: প্রতিটি block-এর ভেতরে জায়গা নষ্ট
  • Stack overflow heap-এর খাতা নষ্ট করেছে
  • Header-এর জন্য 744 byte যথেষ্ট নয়

Clang বা GCC-র -fstack-usage-এর একটি লাইন: vla.c:2:sum_n 24 dynamic. “dynamic” মানে কী?

  • Function-টি heap থেকে 24 byte নেয়
  • Function-টি recursive
  • Frame সবসময় ঠিক 24 byte
  • স্থির 24 byte-এর সঙ্গে চলার সময় ঠিক হওয়া আরও কিছু (যেমন VLA)

একটি function-এর শেষ কাজ আরেকটি function ডাকা, আর compiler সেখানে pop করে তারপর b (bl নয়) দিয়েছে। Stack-এর গভীরতায় এর প্রভাব কী?

  • দুটি frame একসঙ্গে stack-এ থাকে, তাই গভীরতা বাড়ে
  • Caller-এর frame আগেই ফেরত যায়, তাই ডাকা function এক স্তর কম গভীরে চলে
  • ফেরার ঠিকানা হারিয়ে যায়, তাই program ভেঙে পড়ে
  • Interrupt বন্ধ থাকে, তাই stack-এ ISR frame আসে না

Linker script বদলে stack SRAM-এর একেবারে শুরুতে (তার নিচে কোনো memory নেই) আর .data/.bss তার ওপরে বসানো হলো। Stack overflow-এর আচরণ কীভাবে বদলায়?

  • Stack আরও বড় হয়, তাই overflow আর হয় না
  • Overflow এখন .data নষ্ট করে, .bss নয়
  • নীরব data-নষ্টের বদলে উপচানোর সঙ্গে সঙ্গে fault হয়
  • প্রতিটি function-এর frame ছোট হয়ে যায়

শব্দকোষ

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

মনে রাখুন

  1. বাজেট: map file দেয় flash আর static SRAM-এর খরচ (scale: 2188 আর 12 byte); stack-এর চাহিদা map file-এ নেই, তা হিসাব আর মাপ থেকে আসে।
  2. Stack-এর হিসাব: -fstack-usage-এর frame + call graph-এর সবচেয়ে গভীর পথ (tail call-এ caller-এর frame বাদ) + প্রতিটি preemption স্তরে 36 byte-এর interrupt frame আর handler + মার্জিন। Recursion থাকলে সীমা নেই।
  3. Painting: high-water mark একটি মাপা নিম্নসীমা (scale-এ 76 byte), প্রমাণ নয়; সবচেয়ে খারাপ মুহূর্তে interrupt এলে 112.
  4. Overflow: stack-এর নিচে data থাকলে ক্ষতি নীরব (tare 134218569 g); একটি word-এর canary ফসকাতে পারে, guard band ধরে কিন্তু ঠেকায় না; stack নিচে বসানো, MPU বা stack limit register দ্রুত fault দেয়।
  5. Heap নয়, static: fragmentation, অনির্দিষ্ট সময়, leak আর ISR-এর বিপদ; বদলে নির্দিষ্ট মাপের global, এক মাপের pool, ring buffer আর শুধু-শুরুতে বরাদ্দ।

পরের পর্বে: পর্ব ৪০ (Fixed-point গণিত — float ছাড়া দ্রুত আর নিরাপদ হিসাব). Q15 আর Q16.16 format, গুণ-ভাগে scaling আর rounding, saturation, আর FPU-হীন Cortex-M3-এ float-এর আসল খরচ, বাজারঘরের scale-এর calibration দিয়ে।

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

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