0% found this document useful (0 votes)
83 views12 pages

Classifying Isas: Accumulator (Before 1960) : Stack (1960S To 1970S) : Memory-Memory (1970S To 1980S)

The document discusses different instruction set architectures (ISAs) for computers including accumulator, stack, memory-memory, register-memory, register-register load/store architectures. It provides examples of how an arithmetic expression would be computed in each architecture and lists the pros and cons of each approach. Register-register load/store architectures are now most common as they allow for pipelining and parallelism while keeping memory traffic low.

Uploaded by

Jaswanth Vemula
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
83 views12 pages

Classifying Isas: Accumulator (Before 1960) : Stack (1960S To 1970S) : Memory-Memory (1970S To 1980S)

The document discusses different instruction set architectures (ISAs) for computers including accumulator, stack, memory-memory, register-memory, register-register load/store architectures. It provides examples of how an arithmetic expression would be computed in each architecture and lists the pros and cons of each approach. Register-register load/store architectures are now most common as they allow for pipelining and parallelism while keeping memory traffic low.

Uploaded by

Jaswanth Vemula
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 12

Classifying ISAs

Accumulator (before 1960):


1 address add A acc <- acc + mem[A]

Stack (1960s to 1970s):


0 address add tos <- tos + next

Memory-Memory (1970s to 1980s):


2 address add A, B mem[A] <- mem[A] + mem[B]
3 address add A, B, C mem[A] <- mem[B] + mem[C]

Register-Memory (1970s to present):


2 address add R1, A R1 <- R1 + mem[A]
load R1, A R1 <_ mem[A]

Register-Register (Load/Store) (1960s to present):


3 address add R1, R2, R3 R1 <- R2 + R3
load R1, R2 R1 <- mem[R2]
store R1, R2 mem[R1] <- R2
Stack Architectures
• Instruction set:
add, sub, mult, div, . . .
push A, pop A
• Example: A*B - (A+C*B)
push A
push B
mul
push A
push C A C B B*C A+B*C result
A B A*B
push B A A*B A C A A*B
mul A*B A A*B
add A*B
sub
Stacks: Pros and Cons
• Pros
– Good code density (implicit operand addressing top of stack)
– Low hardware requirements
– Easy to write a simpler compiler for stack architectures
• Cons
– Stack becomes the bottleneck
– Little ability for parallelism or pipelining
– Data is not always at the top of stack when need, so additional
instructions like TOP and SWAP are needed
– Difficult to write an optimizing compiler for stack architectures
Accumulator Architectures
• Instruction set:
add A, sub A, mult A, div A, . . .
load A, store A

• Example: A*B - (A+C*B)


load B
B B*C A+B*C A+B*C A A*B result
mul C
add A
store D
load A
mul B
sub D
Accumulators: Pros and Cons
• Pros
– Very low hardware requirements
– Easy to design and understand
• Cons
– Accumulator becomes the bottleneck
– Little ability for parallelism or pipelining
– High memory traffic
Memory-Memory Architectures

• Instruction set:
(3 operands) add A, B, C sub A, B, C mul A, B, C

• Example: A*B - (A+C*B)


– 3 operands
mul D, A, B
mul E, C, B
add E, A, E
sub E, D, E
Memory-Memory:
Pros and Cons
• Pros
– Requires fewer instructions (especially if 3 operands)
– Easy to write compilers for (especially if 3 operands)
• Cons
– Very high memory traffic (especially if 3 operands)
– Variable number of clocks per instruction (especially if 2 operands)
– With two operands, more data movements are required
Register-Memory Architectures
• Instruction set:
add R1, A sub R1, A mul R1, B
load R1, A store R1, A
• Example: A*B - (A+C*B)
load R1, A
mul R1, B /* A*B */
store R1, D
load R2, C
mul R2, B /* C*B */
add R2, A /* A + CB */
sub R2, D /* AB - (A + C*B) */
Memory-Register:
Pros and Cons
• Pros
– Some data can be accessed without loading first
– Instruction format easy to encode
– Good code density

• Cons
– Operands are not equivalent (poor orthogonality)
– Variable number of clocks per instruction
– May limit number of registers
Load-Store Architectures
• Instruction set:
add R1, R2, R3 sub R1, R2, R3 mul R1, R2, R3
load R1, R4 store R1, R4
• Example: A*B - (A+C*B)
load R1, &A
load R2, &B
load R3, &C
load R4, R1
load R5, R2
load R6, R3
mul R7, R6, R5 /* C*B */
add R8, R7, R4 /* A + C*B */
mul R9, R4, R5 /* A*B */
sub R10, R9, R8 /* A*B - (A+C*B) */
Load-Store:
Pros and Cons
• Pros
– Simple, fixed length instruction encoding
– Instructions take similar number of cycles
– Relatively easy to pipeline

• Cons
– Higher instruction count
– Not all instructions need three operands
– Dependent on good compiler
Registers:
Advantages and Disadvantages
• Advantages
– Faster than cache (no addressing mode or tags)
– Deterministic (no misses)
– Can replicate (multiple read ports)
– Short identifier (typically 3 to 8 bits)
– Reduce memory traffic

• Disadvantages
– Need to save and restore on procedure calls and context
switch
– Can’t take the address of a register (for pointers)
– Fixed size (can’t store strings or structures efficiently)
– Compiler must manage

You might also like