Past exam question: 2081 Chaitra (Regular), Q10
Open in the Padhaiko appCompare and contrast between accumulator based and register based architecture.
Solution
Architectural Principles:
- Accumulator-based Architecture:
- Built around a single primary working register called the Accumulator (e.g. Register A in 8085).
- In nearly all arithmetic and logic instructions, one operand is implicitly the accumulator, and the result is always stored back into the accumulator.
- Employs 1-address instruction format (e.g.
ADD BimpliesA = A + B) or 0-address format for implied operations (CMA).
- Register-based (General-Purpose Register) Architecture:
- Built around a bank of multiple equivalent general-purpose registers (e.g. AX, BX, CX, DX in 8086; R0–R31 in ARM/MIPS).
- Instructions explicitly designate any register as source or destination operands.
- Employs 2-address format (
MOV AX, BX->AX = BX,ADD AX, BX->AX = AX + BX) or 3-address format (ADD R1, R2, R3->R1 = R2 + R3).
Comparison Table:
| Feature | Accumulator-based Architecture | Register-based Architecture |
|---|---|---|
| Working Registers | Single primary accumulator register | Multiple general-purpose registers |
| Instruction Format | 1-address (or 0-address) format | 2-address or 3-address format |
| Instruction Length | Short instruction length (opcode + 1 operand) | Longer instruction length (multiple register fields) |
| Operand Bottleneck | Severe accumulator bottleneck; high memory traffic | Low bottleneck; intermediate data stays in registers |
| Code Size | High code density (fewer address bits needed) | Lower code density (more bits per instruction) |
| Memory Bus Traffic | High (frequent store/reload of accumulator) | Low (registers hold multiple temporary variables) |
| Hardware Complexity | Simple internal routing and decoding logic | Complex register file, bypass buses, and decoding |
| Execution Throughput | Slower for complex expressions | Much faster due to register-level parallelism |
| Examples | Intel 8085, MOS 6502, PDP-8 | Intel 8086, ARM Cortex, MIPS, RISC-V |
Summary of Trade-Offs: Accumulator-based architectures minimize instruction word width and silicon area at the expense of requiring frequent memory stores and reloads whenever intermediate results are generated. Register-based architectures increase instruction width and register file silicon, but dramatically reduce memory bus traffic and facilitate compiler optimization for high-speed execution.
Accumulator-based architecture uses 1-address instructions with a single implied accumulator register for results (compact instructions but high memory traffic), whereas register-based architecture uses 2- or 3-address instructions across multiple general-purpose registers (reducing memory traffic and increasing throughput).