Chapter 4, Simple Calculations

• We now depart the foundations section
• And start a section called Computer Architecture

• Two types of computer architectures
  • CISC - Complex Instruction Set Computer
    • Instructions ease the job of the programmer
    • Multiple actions accomplished with a single instruction
    • Example

      • add desitnation, source1, source2
        	   

      • Load M[source1]
        Load M[source2]
        Add 
        Store M[destination]
        	   

    • This tends to lead to very large instruction sets
      • Add memory, memory, memory
      • Add register, memory, memory
      • Add register, register, memory
      • 2³ combinations
      • The same applies to all other math operations
      • Probably many more branch instructions
      • Probably instructions for branch and decrement ...
      • And other instructions as well
    • This means we have to use more bits to encode the instructions
    • This also means we have multiple words per instruction.
    • Which means we have more memory access per instruction on the fetch part of the instruction cycle.
  • RISC - Reduced Instruction Set Computer
    • Most programs are written in a high level language
    • There is no need to make it easy for people to write assembly language.
    • Along with the statements from the previous section
    • Statistical studies show that 90% of the instructions executed were from 10% of the instruction set
    • IE Most instructions were very infrequently used.
    • RISC throws most of these away.
      • There is only 1 add instruction
      • add R_dest, R_src1, R_src2
      • So how do we accomplish an add as described above?
      • What does it cost?
      • Another benifit from RISC is the processor is easier to design
        • Fewer instructions to decode => less logic in CU
        • fewer states and control lines too!
        • We can also encode all instructions in a single word.
      • This tends to lead to faster (MIPS) hardware.
      • But does it accomplsh the same thing as CISC?
      • This is why MIPS in not a valid measure over architectures.
      • Much more on performance evaluation in Architecture II

• Addresses in a computation.
  • Evaluate a=a*b+c*d*e
    • a = a*b
    • t1 = c*d
    • t1 = t1 * e
    • a = a + t1
  • The first operation is called a multiply-and-store
  • In this example, each operation is considered a ternary operation
  • Each performs a math operation and a store.
  • Consider copy source dest
  • This is a binary operation
  • Consider jump destination
  • This is a unary operation
  • In some sense, operands are equivelent to addresses (memory accesses)
  • Let us consider instructions in terms of the number of memory accesses they require
    • 3 address machines
      • Instructions are in the form inst dest src1 src2
      • Add dest src1 src2
      • M[dest] = M[src1] + M[src2]

      • mpy 100 100 104  ; a = a * b
        mpy 200 108 112  ; t1 = c * d
        mpy 200 200 116  ; t1 = t1 * e
        add 100 200 100  ; a = a + t1
        	     

      • There are a total of 4 memory access per instruction
      • Or a total of 16 memory accesses
    • 2 address machines
      • instructions are of the form inst dest src1
      • Add dest src1
      • M[dest] = M[dest] + M[src]i

      • mpy 100, 104
        move 200, 108
        mpy 200, 112
        mpy 200, 116
        add 100, 200
        	     

      • Here each instruction has three memory accesses
      • Or a total of 15 memory accesses
      • But note, it takes an extra instruction.
    • 1 address machines
      • This type of machine has an accumulator
      • Instructions of the form inst src
      • Add src1
      • acc = acc + M[src]

      • load 100
        mpy 104
        store 100
        load 108
        mpy 112
        mpy 116
        add 100
        store 100
        	     

      • Each has two memeory accesses
      • This has a total of 16 memory accesses
      • And used 8 instruction
    • 0 address machines
      • Use a stack to perform operations
      • Instructions are of the form op
      • add
      • This will add the top two values on the stack and put them back onto the stack
      • Two special, push addr, pop addr

      • push 100
        push 104
        mpy
        push 108
        push 112
        mpy
        push 116
        mpy
        add 
        pop 100
        	     

      • This takes 16 memory accesses as well
      • But uses 10 instructions
    • Conclusions
      • Notice, as we decrease addresses in each instruction we decrease the size of the instructions
      • We also increase the number of instructions needed to accomplish anything.