এমবেডেড সিস্টেমে ইন্টারাপ্ট — প্রায়োরিটি ও লেটেন্সি

১ · রিক্যাপ — ইন্টারাপ্ট আসলে কী

সংক্ষেপে — একটি ইন্টারাপ্ট রিকোয়েস্ট (IRQ) হলো হার্ডওয়্যারের (একটি টাইমার ওভারফ্লো, একটি UART বাইট রিসিভ, একটি GPIO পিনের স্টেট পরিবর্তন) পক্ষ থেকে CPU-কে পাঠানো একটি সংকেত — "এখনই তোমার মূল কাজ থামিয়ে আমাকে সার্ভিস করো"। CPU তখন একটি ছোট ফাংশন — ইন্টারাপ্ট সার্ভিস রুটিন (ISR) — চালায়, তারপর মূল কাজে ফিরে যায়। একটি বাস্তব মাইক্রোকন্ট্রোলারে একই সময়ে একাধিক ভিন্ন উৎস থেকে IRQ পেন্ডিং থাকতে পারে — টাইমার, UART, ADC, GPIO — সবাই একসাথে CPU-এর দৃষ্টি আকর্ষণের চেষ্টা করতে পারে।

২ · প্রায়োরিটি লেভেল ও নেস্টেড ইন্টারাপ্ট

যদি একসাথে একাধিক IRQ পেন্ডিং থাকে, CPU কোনটা আগে সার্ভিস করবে তা ঠিক করতে প্রতিটি ইন্টারাপ্ট উৎসকে একটি প্রায়োরিটি লেভেল দেওয়া হয় (কনফিগারযোগ্য রেজিস্টারের মাধ্যমে)। নিয়ম সহজ — সবচেয়ে বেশি প্রায়োরিটির পেন্ডিং IRQ সবসময় আগে সার্ভিস পায়, এটা কখন এসেছে তা বিবেচ্য নয়।

এখান থেকেই আসে নেস্টেড ইন্টারাপ্টNested Interruptএকটি নিম্ন-প্রায়োরিটি ISR চলাকালীন একটি উচ্চ-প্রায়োরিটি IRQ এলে সেটি চলমান ISR-কে প্রি-এম্পট করে নিজে আগে চলে। — যদি CPU ইতিমধ্যে একটি নিম্ন-প্রায়োরিটি ISR চালাচ্ছে, আর ঠিক তখনই একটি উচ্চ-প্রায়োরিটি IRQ আসে, তাহলে সেই চলমান ISR-কে প্রি-এম্পট করে (নিজের স্টেট সেভ করে থেমে) উচ্চ-প্রায়োরিটি ISR আগে চলে, তারপর আবার নিম্ন-প্রায়োরিটি ISR-এ ফিরে আসা হয় — অনেকটা একটি ফাংশন কলের ভেতরে আরেকটি ফাংশন কল "নেস্ট" করার মতো। প্রতিটি মাইক্রোকন্ট্রোলার ফ্যামিলির নিজস্ব ইন্টারাপ্ট কন্ট্রোলার এই প্রি-এম্পশন লজিক হার্ডওয়্যারেই বাস্তবায়ন করে (যেমন ARM Cortex-M-এর NVIC)।

৩ · ইন্টারাপ্ট লেটেন্সি

ইন্টারাপ্ট লেটেন্সিInterrupt Latencyহার্ডওয়্যার ইভেন্ট ঘটার মুহূর্ত থেকে ISR-এর প্রথম ইনস্ট্রাকশন সত্যিই চলা শুরু হওয়া পর্যন্ত সময়। হলো হার্ডওয়্যার ইভেন্ট ঘটার মুহূর্ত (t=0) থেকে ISR-এর প্রথম ইনস্ট্রাকশন সত্যিই চলা শুরু হওয়া পর্যন্ত সময় — বাস্তবে এটি কখনোই শূন্য নয়। এর প্রধান উপাদানগুলো:

অর্থাৎ — CPU-কে প্রথমে বর্তমান চলমান ইনস্ট্রাকশনটি শেষ করতে হয় (তাৎক্ষণিকভাবে মাঝপথে থামতে পারে না), তারপর বর্তমান রেজিস্টার/স্টেট স্ট্যাকে সেভ করতে হয় (যাতে ISR শেষে ঠিক আগের জায়গা থেকে চালিয়ে যাওয়া যায়), তারপর ইন্টারাপ্ট ভেক্টর টেবিল থেকে সঠিক ISR-এর ঠিকানা ফেচ করতে হয় — এই তিনটি ধাপ শেষ হওয়ার পরই ISR-এর আসল কোড চলা শুরু হয়। যদি ইতিমধ্যে একটি সমান বা বেশি প্রায়োরিটির ISR চলমান থাকে, নতুন IRQ-কে সেটি শেষ হওয়া পর্যন্ত (বা প্রি-এম্পট করতে না পারা পর্যন্ত) আরও অপেক্ষা করতে হয় — এই অতিরিক্ত অপেক্ষাও লেটেন্সির অংশ। এই কারণেই হার্ড রিয়েল-টাইম সিস্টেমে (M7-এর পরের পাঠে বিস্তারিত) সর্বোচ্চ সম্ভাব্য লেটেন্সি একটি নির্দিষ্ট সীমার মধ্যে থাকা নিশ্চিত করা জরুরি।

৪ · একটি সত্যিকারের সিমুলেশন — প্রায়োরিটি-চালিত ডিসপ্যাচার

নিচের কোডে পাঁচটি IRQ বিভিন্ন সিমুলেটেড টিকে বিভিন্ন প্রায়োরিটি নিয়ে আসছে (প্রায়োরিটি ১ = সবচেয়ে জরুরি, সংখ্যা যত বাড়বে প্রায়োরিটি তত কমবে)। ডিসপ্যাচার প্রতি টিকে পেন্ডিং তালিকা থেকে সবচেয়ে বেশি প্রায়োরিটিরটি বেছে নেয় — প্রয়োজনে চলমান একটি ISR-কেও প্রি-এম্পট করে। ট্রেসটি লক্ষ করুন — এটি সত্যিই গণনা করে দেখাচ্ছে যে সার্ভিসের ক্রম FIFO নয়, প্রায়োরিটি-চালিত।

class InterruptRequest:
    def __init__(self, name, priority, arrival_tick, service_ticks):
        self.name = name
        self.priority = priority  # ১ = সর্বোচ্চ প্রায়োরিটি, সংখ্যা বাড়লে প্রায়োরিটি কমে
        self.arrival_tick = arrival_tick
        self.service_ticks = service_ticks
        self.remaining = service_ticks
        self.first_start_tick = None
        self.completion_tick = None


irqs = [
    InterruptRequest("UART_RX",    priority=3, arrival_tick=0, service_ticks=2),
    InterruptRequest("TIMER_OVF",  priority=2, arrival_tick=1, service_ticks=1),
    InterruptRequest("ADC_DONE",   priority=4, arrival_tick=1, service_ticks=2),
    InterruptRequest("EXT_BUTTON", priority=1, arrival_tick=3, service_ticks=1),
    InterruptRequest("SPI_DONE",   priority=3, arrival_tick=4, service_ticks=1),
]

TOTAL_TICKS = 9
arrival_by_tick = {}
for irq in irqs:
    arrival_by_tick.setdefault(irq.arrival_tick, []).append(irq)

pending = []
current = None
trace = []

for tick in range(TOTAL_TICKS):
    for irq in arrival_by_tick.get(tick, []):
        pending.append(irq)
        trace.append(f"tick {tick}: {irq.name} (priority={irq.priority}) এসে পৌঁছাল")

    if pending:
        pending.sort(key=lambda r: (r.priority, r.arrival_tick))
        best = pending[0]
        if current is None or best.priority < current.priority:
            if current is not None:
                pending.append(current)
                pending.sort(key=lambda r: (r.priority, r.arrival_tick))
                trace.append(f"tick {tick}: {current.name} প্রি-এম্পটেড হলো (উচ্চ-প্রায়োরিটি {best.name} এসেছে)")
            current = pending.pop(0)
            if current.first_start_tick is None:
                current.first_start_tick = tick

    if current is not None:
        current.remaining -= 1
        trace.append(f"tick {tick}: {current.name} সার্ভিস হচ্ছে (priority={current.priority}, বাকি={current.remaining})")
        if current.remaining == 0:
            current.completion_tick = tick
            trace.append(f"tick {tick}: {current.name} সম্পন্ন হলো")
            current = None
    else:
        trace.append(f"tick {tick}: CPU আইডল")

for line in trace:
    print(line)

print()
print(f"{'IRQ':<12}{'priority':<10}{'arrival':<9}{'start':<8}{'complete':<10}{'latency':<9}")
for irq in irqs:
    latency = irq.first_start_tick - irq.arrival_tick
    print(f"{irq.name:<12}{irq.priority:<10}{irq.arrival_tick:<9}{irq.first_start_tick:<8}{irq.completion_tick:<10}{latency:<9}")

completion_order = sorted(irqs, key=lambda r: r.completion_tick)
print("\nসম্পন্ন হওয়ার প্রকৃত ক্রম:", [r.name for r in completion_order])