Computer Architecture Lab/SS2013/GROUP4 ASSIGNMENT1

Group 4
Ioannis Kotleas s122576
Chatzigeorgakidis Georgios s121078
Dean Roy Humphreys s120971
Tobias Bennike Aagren s112345

Short presentation and comparison of instruction set characteristics for

Intel 8008
MIPS32 (1981)
RTX 2000

Intel 8008 8-bit parallel CPU (1972)

Intel 8008 was an 8-bit (byte-oriented) parallel microprocessor that used an accumulator, six 8-bit index registers, a 14-bit program counter and seven 14-bit registers in an address stack, used internally to store program and subroutine addresses. The 14-bit program counter provides direct access to 16 Kilobytes of memory. Two of the six 8bit registers mentioned before provide indirect memory addressing capability. The Instruction Set of Intel 8008 uses the 8-bit accumulator in order to execute the instructions through an Arithmetic Logic Unit (ALU). The first operand for the ALU is the 8-bit accumulator, passed on to a temporary register, while the second one is either an index register or an immediate in the instruction or a value read from memory and stored in the second 8-bit temporary register. The 8008 chip did not meet the Computer Terminal Corporation (CTC) performance goals and was used later in calculators, as well as in the first commercial Personal Computers.

Architecture/Specifications

One 8-bit instruction register

The scratch pad memory (seven 8-bit registers)

◦ One 8-bit accumulator

◦ Six 8-bit index registers

Address stack (eight 14-bit registers)

◦ One 14-bit program counter

◦ Seven 14-bit for address storage for nesting subroutines up to seven levels

Two 8-bit temporary registers (The operands of the ALU)

One 8-bit parallel Arithmetic Logic Unit (ALU) that supports addition, subtraction and logical operations

16 Kilobytes of memory

Input and output buffers

500KHz clock

20 μs average instruction cycle time

Instruction Set/Instruction Format

48 Instructions with three different instruction formats of 1, 2 or 3 bytes in length

◦ 1 byte – opcode :register to register, memory reference, I/O arithmetic or logical, rotate or return instructions

D₇ D₆ D₅ D₄ D₃ D₂ D₁ D₀

opcode

◦ 2 bytes – opcode and operand: Immediate mode instructions

D₇ D₆ D₅ D₄ D₃ D₂ D₁ D₀	opcode
D₇ D₆ D₅ D₄ D₃ D₂ D₁ D₀	operand

◦ 3 bytes – opcode and 14 bit address: JUMP or CALL instructions

D₇ D₆ D₅ D₄ D₃ D₂ D₁ D₀	opcode
x x D₅ D₄ D₃ D₂ D₁ D₀	LOW address
D₇ D₆ D₅ D₄ D₃ D₂ D₁ D₀	HIGH address

5-cycle computation per byte of instruction

5 instruction groups

◦ Index register instructions: Load data to registers, load data immediate, increment/decrement index register

◦ Accumulator group instructions: ALU index register instructions, ALU operations with memory, rotate instructions

◦ Program Counter and stack control instructions: Return instructions, restart instruction

◦ Input/Output instructions: INP, OUT

◦ Machine Instruction: Halt Instruction

Addressing modes

Register

Immediate

Register indirect

MIPS Technologies MIPS32 (1981)

MIPS32 is a 32-bit revision of the Microprocessor without Interlocked Pipeline Stages (MIPS) Instruction Set Architecture (ISA). It is a Reduced Instruction Set Computing architecture (RISC) developed by the MIPS Technologies. RISC architecture is in an attempt to reduce the complexity of the ISA and hence increase the speed. MIPS belongs to the load-store (register-register) type of architecture and relies heavily on registers, which makes it extremely fast but increases the instructions required for more complex operations. However, this setup lends itself well to pipelining and studies show that multiple simple instructions are more effective on average than more complex instructions that take a longer time to execute.

Architecture/Specifications

MIPS uses a fixed-length instruction of 32 bits

Each instruction can have a maximum of 3 operands, all of which are register-based

◦ No operation can be done on a value in memory, a load/store operation must be executed to move the data around

32-bit wide (1 word) registers

32 General Purpose Registers (GPR)

Register $0 has a constant value of zero

Register $1 is reserved for the assembler to handle pseudo-instructions

Two special registers, HI and LO which are used for multiplication overflow

One 32-bit Arithmetic Logic Unit (ALU) that supports addition, subtraction and logical operations

Instruction Set/Instruction formats

MIPS has three instruction formats as shown in the table below:

R-Type	opcode(6)	rs(5)	rt(5)	rd(5)	shift amt(5)	function(6)
I-Type	opcode(6)	rs(5)	rt(5)	address(16)
J-Type	opcode(6)	address(26)

R-Type instructions perform operations on registers (i.e. add, sub, xor…)

I-Type instructions perform immediate operations such as adding constants and checking for equality (addi, subi, beq…)

J-Type instructions are jump instructions which move the Program Counter (PC) to different locations in the program (j, jal…)

Addressing modes

MIPS supports 3 different addressing modes:

Register

Immediate

Base + Displacement

RTX 2000

RTX 2000 is a 16-bit microcontroller designed to solve problems connected with embedded real-time systems. It is an improvement on Novix stack machines which could directly execute the Forth programming language. RTX 2000 implements subroutine calls in a way that they execute in one machine cycle.

Architecture/Specifications

RTX 2000 uses a fixed-length instruction of 16 bits (with the exception of long literals, which uses 16 bits for the instruction and 16 bits for the literal value).

RTX 2000 is a stack machine based on two-stack architecture.

Implements 2 stacks of 256 words.

One data stack and one return stack.

◦ Data stack is used for expression evaluation and subroutine parameter passing.

◦ Return stack is used for subroutine return address storage and for loop counter storage

8 16-bit internal registers (TOP, NEXT, IR, PC, CR, I, MD, SR)

◦ TOP has the top item of the parameter stack where NEXT contains the second item.

◦ IR has the executing instruction, where PC contains the address for the next instruction to be executed.

◦ I is the Index Register

◦ MD and SR are used as intermediate values for calculations.

Instruction Set/Instruction formats/Instruction Classes

RTX 2000 has one general instruction format:

Class (12-15)

ALU(8-11)

SC(6-7)

Return bit (5)

Data (0-4)

In the four most significant bits of the instruction the class type is indicated:

Class:	Operation:
0-7	Subroutine call
8-9	Branches and loops
10	Math/logic functions
11	Register and short literal operations
12	User memory access
13	Long literals
14	Memory access by word
15	Memory access by byte

Comparison

The following table summarizes the above Instruction Set Architectures for reasons of comparison.

Attribute	Instruction Set Architecture
	Intel 8008	RTX 2000	MIPS
Design Strategy	led to CISC	Inspired by RISC	RISC
Architecture type	Accumulator	Stack-based	Load-Store
Max Operands	2	-	3
Memory Operands	1	-	0
Total Registers	6 general 8-bit registers Accumulator and temporary operand registers 8 internal 14-bit registers	8 Internal	32 general + 2 special
Instruction Length	Variable 1, 2 or 3 bytes	Fixed 16-bit	Fixed 32-bit
Instruction Formats	3	1	3
Addressing Modes	Register Immediate Register indirect	-	Register Immediate Base+Displacement
No of Instructions	48	53	45

Intel 8008 is an ancestor of Complex Instruction Set Computing (CISC), meaning that it can execute multiple-step operations with one instruction. However, this technique is not very well welcomed by the compiler developers because it introduces complexity. On the other hand, MIPS is a Reduced Instruction Set Computing architecture (RISC). Despite the fact that it may need more than one step for some operations, its simplicity attracts many compiler developers. The lost speed is gained due to the fast access to 32 general usage registers which can be utilized to store local variables and reduce therefore load-store operations and to the use of fixed-size instructions (Intel 8008 uses variable-size instructions). This allows for easy fetching and decoding of instructions and greatly simplifies pipelining. However, a fixed instruction length can cause limitations for instructions that require more bits than available, but these instructions are known to occur less frequently and hence prove less of an issue. Also, some instructions require less than 32 bits and in these cases bits are essentially wasted. MIPS has 32 General Purpose Registers, which simplifies even more the creation of the compiler, as the developer will always have enough registers available for the operations. The simplicity of MIPS is also apparent in the Instruction Formats.

References

1. 8-Bit Parallel Central Processor Unit Users Manual, Intel Corporation 1972

2. MIPS32® Instruction Set Quick Reference ([1])

3. The Harris RTX 2000 Microcontroller ([2])

4. Computer Architecture: A Quantitative Approach, Fifth Edition, John L. Hennessy and David A. Patterson, Morgan Kaufmann, 2012