26.9. Similarities Between Interrupts and Subroutine Calls

When an interrupt occurs or a subroutine is called, the processor must save its current state, which includes registers, the program counter, and the program status word.

When the processor receives an interrupt signal (from an I/O device, for example), it needs to pause its current task to handle the interrupt. To do so, it first saves its current state, which involves storing the contents of various registers and the program counter—this tells the processor where to return after the interrupt is processed. Similarly, when a subroutine is called, the same saving of state occurs, allowing the main program to be paused while the subroutine runs. This saved information is typically stored in a location called the stack, which operates on a Last In, First Out (LIFO) principle.

Imagine you are reading a book (the main program) and suddenly receive a phone call (the interrupt). Before answering, you place a bookmark (saving the state) to ensure you can return to the exact spot where you left off. After finishing the call, you can remove the bookmark and go back to reading.

After saving the state, the processor loads a new program counter value, effectively shifting control to the interrupt service routine or subroutine.

Once the current state is saved, the processor now needs to switch to executing the code associated with the interrupt or subroutine. For interrupts, this involves loading the program counter with the address of the interrupt service routine—a special piece of code designed to handle that specific interrupt. For subroutines, it similarly involves setting the program counter to the address where the subroutine code starts. After the interrupt or subroutine execution is completed, the processor retrieves the saved state to continue from where it left off.

Returning to our phone call scenario, after you answer the call, you change your focus to the conversation (executing the interrupt). Once the call is over and you hang up, you can put down the phone and go back to your book (the main program) using the bookmark to find your exact place.

The CPU checks for interrupts at the end of each instruction cycle, ensuring that multiple interrupts can be effectively managed by queuing or prioritizing them.

After executing an instruction, the processor checks if any interrupts are pending. If multiple interrupts occur, managing them can be critical. This often involves prioritizing certain interrupts over others, ensuring that more urgent tasks (such as responding to critical hardware signals) are handled promptly, while less urgent tasks may be deferred. Subroutines can also be similar, as a subroutine can call other subroutines, creating a nesting effect that requires careful management of the execution order and state saving.

Think of an executive managing multiple tasks. At the end of a meeting or phone call (instruction cycle), they check their messages or notifications (interrupts). If they have several notifications, they prioritize them—urgent messages are addressed first, while others may be noted for later. If they need to answer an urgent message during a meeting (nested subroutine), they quickly address it and return to their previous meeting.

--