23.1.1. Introduction to Interrupt

An interrupt is a signal to the processor emitted by hardware or software indicating an event that needs immediate attention.

An interrupt occurs when the normal flow of execution in a program is disrupted. This can be caused by hardware events, like input/output operations, which require the processor to stop its current activity and address the urgent task. This mechanism ensures that the CPU can respond swiftly to critical events.

Think of an interrupt like a phone call while you're in the middle of a conversation. Just as you would pause your current discussion to answer an important call, the CPU pauses its current task to address the interrupt.

When an interrupt occurs, the current value of the program counter (PC) and other registers are saved onto a stack.

The program counter (PC) indicates the next instruction to execute. When an interrupt occurs, it's critical to save the PC's current value so that once the interrupt has been serviced, the program can resume from the correct point. The saved state includes the current register values, which might affect the execution of the instructions after returning from the interrupt.

Imagine writing an important report while receiving an urgent email. You save your report (the program's state) before jumping to your email (the interrupt). Once you've dealt with the email, you can return to the report exactly where you left off.

After saving the context, the CPU jumps to execute the Interrupt Service Routine (ISR).

The ISR is a predefined code that specifies how to handle the interrupt. The CPU changes the program counter to point to the code that handles the interrupt, called the ISR. This routine contains instructions that serve the specific needs of the interrupt, whether it be reading data, processing input, etc.

Continuing with the phone call analogy, the ISR is like the conversation you have while on the call. You follow a specific script or points to discuss, ensuring that the call is handled effectively before hanging up and going back to your original conversation.

Once the ISR has completed its task, the previous values of the PC and registers are restored from the stack.

After the ISR has finished executing, the processor retrieves the previously saved context from the stack, restoring the PC to the point where it left off. This allows the program to continue executing as if the interrupt had never occurred. The system ensures that the integrity of the program execution flow and data state is maintained.

This is akin to finishing your phone call (ISR) and then putting away your notes (the saved state) to pick up the report (the original task) right where you paused it.

The cycle involves fetching, decoding, executing instructions, and checking for interrupts, only after an instruction completes.

The CPU works in a cycle: it fetches an instruction, decodes it, executes it, and then checks for interrupts only after completing each instruction. This strategy avoids confusion and potential errors that could arise from checking interrupts in the middle of instruction execution, ensuring a clean execution flow.

Consider this process like a chef preparing a meal. The chef finishes one recipe (instruction), plates it, and only then checks if a customer has made a new order (interrupt). This way, the chef avoids mixing tasks and maintains a smooth cooking process.

--