What do you mean by processor organization? Explain various types of processor organization.

Based on this, three types of processor organization are used.

(a) Single accumulator organization

All the operations use one special register called the accumulator (AC). One operand is always in AC and the result is also stored back in AC. The instruction has just one address field, for the second operand in memory. For example, ADD X means $AC \leftarrow AC + M[X]$.

  Memory ---> [ ALU ] ---> [ AC ] ---+
                 ^                   |
                 +-------------------+

This organization is simple and cheap and needs short instructions. But every result must pass through AC, so the program has many load and store instructions, and it is slow. Early computers such as the IBM 701 used it.

(b) General register organization

Here a set of registers, say R1 to R7, is available. Any of them can hold an operand or a result. A multiplexer chooses two source registers for the ALU inputs, a decoder chooses the destination register, and the ALU result goes back to the register file. The control word has the fields for source 1, source 2, destination and the ALU operation. An example instruction is ADD R1, R2, R3, which means $R1 \leftarrow R2 + R3$.

  R1 R2 R3 ... R7
   |  |  |      |
  [MUX A]   [MUX B]
      \       /
       [ ALU ]  <- operation select
          |
   (to registers via decoder)

This organization is fast, because the data stays inside the CPU and fewer memory accesses are needed. Instructions are longer, since they hold two or three register numbers. Most modern CPUs, such as the ARM and RISC-V, use it.

(c) Stack organization

Here the CPU has a stack (LIFO) in memory or in registers, and the operations work on the top of the stack. Most instructions are zero-address. For example, ADD pops two values, adds them and pushes the result. Other instructions are PUSH X and POP X.

This is very good for evaluating expressions written in reverse Polish notation, and it gives very short instructions. It is also used for subroutine calls. However, random access to items in the middle of the stack is hard. Burroughs B5500 used it.

Comparison

In short, the choice depends on cost, speed and the program length that the designer wants.