CSCI 402: Computer Architectures. Instructions: Language of the Computer (1) Fengguang Song Department of Computer & Information Science IUPUI

Transcription

1 Starting Chapter 2: CSCI 402: Computer Architectures Instructions: Language of the Computer (1) Fengguang Song Department of Computer & Information Science IUPUI Contents 2.1 and 2.3 What is instruction? E.g., Operation operand_1 operan_2 What operations are provided by computer? Where and How operands are stored in computer hardware? 6 1

2 First, look at an example of what is instruction 7 High Level Language à Machine Language 32 bits / instruction Compiler Instr. 1 Instr. 2 Instr. 3 2

3 Definition of Instruction Instructions are commands sent by a program to hardware. A computer speaks its own language. Words of the computer s language are called Instructions Vocabulary of all commands understood by a computer architecture is called Instruction Set. Different computers have different Instruction Sets. but most of their aspects are common (just like dialect) Reason: built from same technology and provide same ops. E.g., MIPS, ARMv7, ARMv8 (since 2013, 64bits), Intel X86 In history, computers used simple instruction sets. Why? If language is simple à It is simple to build the hardware and the compiler Today, many modern computers are still using simple instruction sets add c, a, b What Operations Are Provided by Computers Data Movement Load (from memory) Store (to memory) memory-to-memory move register-to-register move input (from I/O device) output (to I/O device) push, pop (to/from stack) Arithmetic Shift Logical Control (Jump/Branch) Subroutine Linkage Interrupt Synchronization String Graphics (MMX) Integer or FP Add, Subtract, Multiply, Divide shift left/right, rotate left/right not, and, or, set, clear unconditional, conditional call, return trap, return test & set (atomic op) search, translate parallel subword ops (SIMD, AVX) 10 3

4 Top 10 80x86 Instructions Rank instruction Integer Average Percent total executed 1 load 22% 2 conditional branch 20% 3 compare 16% 4 store 12% 5 add 8% 6 and 6% 7 sub 5% 8 move register-register 4% 9 call 1% 10 return 1% Only 10 instructions! Total 96% Simple instructions dominate instruction frequency 11 So, What Conclusion Can We Get? 96%? Maybe we can just provide hardware support for those simple instructions! Because they dominate the total number of instructions executed Hence, the following 12 instructions will be supported: load store add subtract move register-register and shift compare equal, compare not equal branch jump call return 12 4

5 Characteristics of Instructions Much more primitive than higher level languages e.g., there is no sophisticated control flow like for, while, switch, etc. Very restrictive add c, a, b Only support few basic arithmetic operations (e.g., see previous slide) Our design goals: Maximize performance, Minimize cost, and Reduce design time This course will focus on the MIPS instruction set 13 The MIPS Instruction Set? Used as examples throughout the textbook Developed by MIPS Technologies ( In 2013, MIPS Technologies was acquired by Imagination Technologies Occupies a large share of embedded system market E.g., consumer electronics, network/storage equipment, cameras, printers Such as Windows CE devices, Sony PlayStation, etc. MIPS represents a typical design of many modern ISAs 14 5

6 Instruction Set Architecture (ISA) ISA serves as the interface between software and hardware. software instruction set hardware It provides the mechanism by which software tells hardware what should be done. Based on ISA High level language code : C, C++, Java, Fortan, compiler Assembly language code: architecture specific statements assembler Machine language code: architecture specific bit patterns 15 Using implicit Operands 4 Categories of ISA 1. Accumulator (before 1960) //The earliest machines 2. Stack (1960s to 1970s) //HP calculator Using explicit Operands??. Memory-Memory (1970s to 1980s) [no longer exists] 3. Register-Memory (1970s to present) //Intel 80x86 4. Register-Register (or Load/Store) (1960s to present) add Ra Rb Rc: Ra Rb + Rc add A: acc acc + mem[a] add: tos tos + next add A B: mem(a) mem(a) + mem(b) add R A: R R + mem[a] Dominant since 1980 s: MIPS, RISC and ARM Some registers may be general purpose; Some may be restricted to special purposes 16 6

7 Why Do We Need Registers? Since 1975, all machines use general purpose registers Advantages of using registers: Registers are faster than memory (1 cycle vs 100 s cycles) Registers are easier and more flexible than Stack or Accumulator for a compiler to use e.g., (A*B) (C*D) (E*F) can do multiplies in any order (vs. stack) Registers can directly store variables So that memory traffic is reduced, program is sped up (since registers are faster than memory) Code Density improves (since register s name has fewer bits than memory location) only 5 bits vs a 64 bits memory address, on MIPS 18 So far, you know what is Instruction and ISA. Next, we ll look at examples of instructions. 19 7

8 How to Support Arithmetic Operations by Instructions? Every computer must perform arithmetic! E.g., on MIPS, add and subtract have 3 operands 2 sources and 1 destination add a, b, c //a ß b + c All arithmetic operations have this format. Exactly 1 operation and 3 varaibles Q: But how to compute b+c+d+e? a = b+c a = a +d a = a + e Why always 3 operands? 1 st Computer Architects Design Principle: Simplicity favors Regularity Regularity makes implementation simpler (i.e., simpler hardware) Then, simplicity enables higher performance at lower cost 20 An Example of MIPS Operation E.g., A line of C code with 5 variables. f = (g + h) - (i + j); Compiled MIPS code has 3 instructions add t0, g, h # temp t0 = g + h add t1, i, j # temp t1 = i + j sub f, t0, t1 # f = t0 - t1 21 8

9 Where and How to Support Operands? Restriction: All arithmetic instructions must use registers as operands MIPS has a number of bit registers Numbered from 0 to 31 Assembler gives names to these 32 registers Registers $t0, $t1,, $t9 for temporary values Registers $s0, $s1,, $s7 for variables that correspond to C variables in source code Design Principle #2: Smaller is faster The reason for having only 32 registers? Too many registers, access time will be longer. Versus main memory: millions of locations 22 Summary of Operands in MIPS 23 9

10 Register Operands Example C code: f = (g + h) - (i + j); Now, suppose g, h, i, j are stored in $s1, $s2, $s3, $s4, f is stored in $s0 Compiled MIPS code become: add $t0, $s1, $s2 add $t1, $s3, $s4 sub $s0, $t0, $t