CP1300 Fetch-Decode-Execute

• An executable binary file contains
  • The machine instructions to be executed
  • Data

• When a program is run
  • The executable binary file is copied from the disk drive into memory
  • The CPU repeated fetches an instruction and executes it using the fetch-decode-execute cycle

• Components of the computer involved in execution
  • Memory: since the instructions and data are stored there
  • The bus: since the instructions and data must be transferred to the CPU
  • The CPU:
    • The ALU manipulates both instructions and data
    • The control logic decodes instructions and identifies what should happen during execution
    • The PC records where the next instruction is in memory
      • The PC is initially set to the starting address of the block of memory
    • The Instruction Register (IR) holds the current instruction
    • The Status Register (SR) records the results of the last instruction

• The Fetch-Decode-Execute Cycle
  • Fetch
    • The PC is copied to the MAR
    • A read signal is sent to memory
    • The instruction is transferred from memory to the MBR
    • The PC is incremented
    • The MBR is copied to the IR
  • Several fetch steps may be required to get all the parts of an instruction
  • Decode
    • Part or all of the instruction in the IR is extracted to determine what is to be done
    • Part of the instruction may contain
      • Data
      • A memory address to get data from
      • A memory address to put data
  • Execute
    • The specified operation is performed
    • Examples
      • Arithmetic operation
      • Logic operation
      • Read or write data from memory
      • Change PC to implement jumps
      • Send data to or from an I/O device
      • Terminate program (by causing an interrupt)
  • Status results are placed in the SR

• Example machine code
  • In binary really, using assembler like commands here
  • Machine language

    LOAD register address-offset

    Loads from memory at the address-offset into the register

    STORE register address-offset

    Stores to memory at the address-offset from the register

    SET register value

    Sets the register to the value

    ADD register

    Adds the contents of the register to the accumulator

    SUBTRACT register

    Subtracts the contents of the register from the accumulator

    JUMP address-offset

    Sets the PC to the address-offset

    JUMPZERO address-offset

    Sets the PC to the address-offset if the accumulator is 0

    END

    Returns control to the OS

  • C++ code

    int Foo, Blah;
    
    Foo = 27;
    Blah = Blah - Foo;
    if (Blah == 0)
        Foo++
              

  • Machine code

    %---- Foo = 27;
     0 SET      ACC 27
     1 STORE    ACC 14
    %---- Blah = Blah - Foo;
     2 LOAD     R0  14
     3 LOAD     ACC 15
     4 SUBTRACT R0
     5 STORE    ACC 15
    %---- if (Blah == 0)
     6 LOAD     ACC 15
     7 JUMPZERO      9
     8 JUMP         13
    %---- Foo++
     9 SET      R0   1
    10 LOAD     ACC 14
    11 ADD      R0
    12 STORE    ACC 14
    13 END
    %---- int Foo, Blah;
    14 "Foo"
    15 "Blah"
         

  • Note that an optimising compiler would remove line 6.

• Another example

  %---- Index = 3;
   0 SET      ACC  3
   1 STORE    ACC 17
  %---- Total = 0;
   2 SET      ACC  0
   3 STORE    ACC 16
  %---- while (Index > 0) {
   4 LOAD     ACC 17
   5 JUMPZERO     15
  %---- Total += Index;
   6 LOAD     ACC 16
   7 LOAD     R0  17
   8 ADD      R0
   9 STORE    ACC 16
  %---- Index--;
  10 LOAD     ACC 17
  11 SET      R0   1
  12 SUBTRACT R0
  13 STORE    ACC 17
  %---- }
  14 JUMP          4
  15 END
  %---- int Total,Index;
  16 "Total"
  17 "Index"
       

Self assessments

• Fetch-Decode-Execute

Tutorial Questions

• Fetch-Decode-Execute

Exam style questions

1. What are the basic stages of the fetch-execute cycle?
2. List 2 registers that are critical to the fetch-execute cycle.
3. Which computer components are important in the fetch-execute cycle? For each, state the reasons why.
4. Can any computer component become involved in the fetch-execute cycle?
5. Describe what happens when an instruction is fetched.
6. Describe what happens while an instruction is decoded.
7. Describe what happens during the execution of an instruction.
8. Given the following abstract computer, manually perform the fetch-execute cycle to run the program already loaded into main memory. Keep track of the state of the registers while the program is running.

   

   The decodes are:

   9999 - stop
   1231 - if R0 > 0 PC = PC - 3
   1356 - R0 = R1
   2546 - R2 = R0 + R1
   5647 - R0 = 4
   6435 - R1 = R0 - 1