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

D7 D6 D5 D4 D3 D2 D1 D0

opcode

◦         2 bytes – opcode and operand: Immediate mode instructions

D7 D6 D5 D4 D3 D2 D1 D0	opcode
D7 D6 D5 D4 D3 D2 D1 D0	operand

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

D7 D6 D5 D4 D3 D2 D1 D0	opcode
x x D5 D4 D3 D2 D1 D0	LOW address
D7 D6 D5 D4 D3 D2 D1 D0	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 ()

3.        The Harris RTX 2000 Microcontroller ()

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