# 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$_7$ D$_6$ D$_5$ D$_4$ D$_3$ D$_2$ D$_1$ D$_0$ opcode
             ◦ 2 bytes – opcode and operand: Immediate mode instructions
                         D$_7$ D$_6$ D$_5$ D$_4$ D$_3$ D$_2$ D$_1$ D$_0$ opcode D$_7$ D$_6$ D$_5$ D$_4$ D$_3$ D$_2$ D$_1$ D$_0$ operand
             ◦ 3 bytes – opcode and 14 bit address: JUMP or CALL instructions
                         D$_7$ D$_6$ D$_5$ D$_4$ D$_3$ D$_2$ D$_1$ D$_0$ opcode x x D$_5$ D$_4$ D$_3$ D$_2$ D$_1$ D$_0$ LOW address D$_7$ D$_6$ D$_5$ D$_4$ D$_3$ D$_2$ D$_1$ D$_0$ 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) | address(16) | address(16) |
| J-Type | opcode(6) | address(26) | address(26) | address(26) | address(26) | 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 | Instruction Set Architecture | 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.