23.1.2. Handling Interrupts

Now, we are coming to the indirect phase of instruction execution that is an interrupt. An interrupt occurs when a normal flow of code is disrupted by hardware or IO devices requiring urgent service.

In computer programming, an interrupt is a signal that temporarily halts the current operations, allowing a different, often more urgent process to be executed. This mechanism ensures that the computer can respond quickly to immediate tasks without completely stopping its main program.

Think of an interrupt like a fire alarm going off in a building. While people are usually engaged in their daily activities, the fire alarm requires everyone to stop what they're doing and respond quickly, similar to how a computer must pause its current task to handle a pressing issue.

After an interrupt occurs, the value of the Program Counter (PC) is saved onto a stack to ensure that after servicing the interrupt, the normal program can resume execution from where it was interrupted.

The Program Counter (PC) is a register that holds the address of the next instruction to execute. When an interrupt occurs, the current value of the PC is saved to a stack—a data structure that stores this information temporarily. This allows the CPU to return to the exact point in the program that it left off after the interrupt has been handled.

Imagine you are reading a book and suddenly have to answer a phone call. You bookmark the page (saving the PC value) before you take the call, ensuring you can return to that same spot once the conversation is over.

Once the PC is saved, the address of the Interrupt Service Routine (ISR) is loaded into the PC. The PC will now execute the instructions defined in the ISR to handle the interrupt.

The ISR is a special code module that executes in response to the interrupt. By loading the ISR address into the PC, the CPU shifts its focus towards addressing the interrupt issue. After completing the ISR tasks, the CPU will pop the saved PC value from the stack to continue executing the original program.

Think of the ISR as a customer service representative who handles specific urgent queries at a store. When a customer has an urgent question (the interrupt), the representative temporarily steps away from attending other customers (the main program) to resolve that specific issue.

After finishing the ISR, the values saved in the stack (like the PC) are restored, allowing the program to continue from where it was interrupted.

Once the ISR has completed its tasks, the prior state of the program is restored by popping the saved data from the stack. This ensures that the program can continue seamlessly, respecting the order of operations that existed before the interrupt took place.

After handling the urgent customer query, the representative returns to assist the other customers from where they left off, just like the program continuing from the exact line of code it was executing before the interrupt.

The Instruction Cycle Code (ICC) is a two-bit code that indicates the current phase of instruction execution, such as fetch, decode, execute, or interrupt.

The ICC serves as an internal marker that helps the CPU understand its current state. It uses two bits to indicate four possible phases: fetching the instruction, decoding it, executing, or servicing an interrupt. This structured approach allows for organized and efficient instruction management.

Imagine a traffic light that uses different colors to signal drivers what to do—red means stop, yellow means prepare to go, and green means go. Similarly, the ICC informs the CPU about what action to take next.

--