Machine Language Instruction Execution

Interrupts are a way of handling events that do not fit neatly into the CPU's ordinary instruction sequence. To understand what an interrupt disrupts, you first need a clear picture of that ordinary sequence. This article describes it. The CPU's normal behavior is a sequential fetch-and-execute process: it repeatedly obtains an instruction and carries it out, one after another.

Before reading on, make a prediction. If a program is stored on a hard disk, does the CPU run it straight from the disk? Think about what you would expect the CPU to need in order to reach each instruction, and then check the answer in the next section.

A machine language instruction is a binary pattern, meaning a sequence of 0s and 1s. It is not a human-level explanation of what should happen. An instruction does not say, in words, 'add these two numbers' or 'wait for a key press.' It is simply a pattern that the CPU recognizes as an instruction to carry out.

This matters for how you think about programs. A program is a collection of these patterns. The CPU has no built-in understanding of what the program is for. It processes the patterns in the order they appear and performs the operation each pattern represents. The source material is explicit that the CPU does not understand events or decide intelligently what to do; it follows the sequence it is given.

The diagram shows the idea of a sequence. Each slot holds one binary pattern. The highlighted slot is the one the CPU is about to handle, and the arrows show that the ordinary flow moves forward through the slots in sequence. The specific patterns are invented for this illustration. The point is that the instructions are stored as patterns and processed in an ordered way.

The CPU's basic cycle has two repeated phases. In the fetch phase, the CPU obtains the next instruction from main memory. In the execute phase, the CPU carries out the operation that instruction describes. After execution, the cycle moves to the following instruction in the sequence and begins again. Because this loop repeats continuously, the whole program is carried out one instruction at a time.

The loop is the heart of ordinary CPU behavior. Notice that it has no built-in exit in this description: the CPU keeps fetching and executing. Interrupts later become interesting precisely because they interfere with this regular rhythm.

The CPU's instruction fetching takes place through main memory. A program stored on a hard disk or solid state drive cannot be executed directly according to the source's model. It must first be loaded into main memory, and only then can the CPU fetch its instructions.

Main memory is the temporary execution workspace. It is comparatively limited and volatile, which means the contents do not persist without power. Storage devices, such as hard disks and solid state drives, provide permanent space for larger amounts of information. The two roles are different, and the difference explains why a program must be copied into main memory before it runs.

An interrupt is studied as a way of handling events that do not fit neatly into the CPU's ordinary instruction sequence. The sequence that an interrupt disrupts is the fetch-execute loop described above. Without a clear picture of the CPU repeatedly fetching instructions from main memory and executing them in order, the effect of an event that breaks into that order cannot be properly understood.