Fetch Execute Cycle

A computer program is made up of sets of instructions that are encoded using the binary numbering system.  The fetch – decode – execute cycle is the order of steps that the Central Processing Unit (CPU) uses to follow instructions.  The fetch execute cycle was first proposed by John von Neumann who is famous for the Von Neumann architecture, the framework which is being followed by most computers today.

The CPU is the brain of the computer and is known as the processor.  It is responsible for implementing a sequence of commands called a program.  A program takes inputs, processes them, and outputs results.  CPUs are found everywhere, like in mobile phones, computer tablets, and washing machines.

A CPU has the following components:

• Control Unit – controls all parts of the computer system. It manages the four basic operations of the Fetch Execute Cycle as follows:
  1. Fetch – gets the next program command from the computer’s memory
  2. Decode – deciphers what the program is telling the computer to do
  3. Execute – carries out the requested action
  4. Store – saves the results to a Register or Memory
• Arithmetic Logic Unit (ALU) – performs arithmetic and logical operations
• Register – saves the most frequently used instructions and data

The primary task of the CPU is to execute programs using the fetch – decode – execute cycle.  This is also called the instruction cycle.  The cycle begins as soon as the computer is turned on and ends when the computer is shut down.

In plain CPUs the fetch execute cycle is carried out progressively, each instruction is being handled before the succeeding one is initiated.  In modern CPUs the fetch execute cycle is executed simultaneously, in parallel via an instruction pipeline, which means the next command starts being executed before the previous command has been completed.  This is made possible since the cycle has been broken up into separate steps.

To run a program, the program code is copied from secondary storage into the primary memory.  The CPU’s program counter is specified to the memory location where the first command in the program has been saved and execution starts.  The program starts running.  A program counter keeps track of the memory address of the command to be executed next.

In a program, each machine code command occupies a space in the main memory.  These memory locations each have a specific memory address.  The program counter saves the address of each command and instructs the CPU in what sequence they should be executed.

When a program is being carried out, the CPU implements the fetch – decode – execute cycle, which recurs over and over again until arriving at the STOP instruction.

Here’s a summary of the fetch – decode – execute cycle:

1. The processor reviews the program counter to see which command to execute next.
2. The program counter gives an address value in the memory of where the next command is.
3. The processor fetches the command value from the memory location.
4. Once the command has been fetched, it needs to be decoded and executed. For example, this could include taking one value, putting it into the Arithmetic Logic Unit (ALU), then taking a different value from a register and adding the two together.
5. Once this has been completed, the processor returns to the program counter to find the next command.
6. This cycle is replicated until the program stops.

The Execute Cycle is the only step useful to the end-user, everything else is required to make the execute cycle happen, as it performs the function of the command.  The ALU is utilized if the command involves arithmetic or logical operations.

Further Readings:

• Instruction cycle