CA226 Advanced Computer Architecture
|
|
- Hugh Mosley
- 5 years ago
- Views:
Transcription
1 Table of Contents Stephen Blott 1
2 Instruction-Set Architectures (ISAs) The functionality of a processor is defined by its: instruction-set architecture (ISA) e.g. 8086, MIPS, ARM, Given the ISA: many possible physical designs are possible the ISA effectively defines the contract between hardware and software 2
3 Four Approaches to ISAs Approaches to ISA differ in their approach to internal memory: stack architecture accumulator architecture general-purpose register (GPRs) architectures: register-memory (RM) memory-memory (MM) 3
4 Stack Architectures Stack architectures: operands for all ALU instructions are implicitly at the top of the stack Example: Push A Push B Add Pop C The only memory operations are Push and Pop. 4
5 Stack Architectures Diagram 5
6 Aside Note Figures from 6
7 Another Example E=(A*B)+(C*D): Push A Push B Mult Push C Push D Mult Add Pop E Note This is essentially the same as operating an RPN Calculator [ wiki/rpn_calculator]. 7
8 Another Example E=(A*B)+(A*D): Push A Push B Mult Push A // fetched again! Push D Mult Add Pop E Note May require additional memory operations. 8
9 Stack Architectures Compact code (just a few bits for each ALU instruction). Specialised addressing for parameters and local variables (e.g. a small offset form the stack pointer). Easy-to-write compilers. Typically require more instructions than a register machine (but resulting code is nevertheless typically denser). Slower than modern GPR machines (there s not much an optimising compiler can do). 9
10 Accumulator Architectures Accumulator architectures: one operand for all ALU instructions is implicitly the accumulator register Example: Load A Add B Store C 10
11 Accumulator Architectures Diagram 11
12 Another Example E=(A*B)+(C*D): Load A Mult B Store E // here Load C Mult B Add E // and here Store E Note That s two additional memory operations. 12
13 Note Both stack and accumulator architectures: are now virtually extinct they: generate too much memory traffic (slow, blocking) make compiler/hardware optimisation difficult 13
14 Example Consider: ` (AxxB)-(BxxC)-(AxxD) ` On a stack architecture: the calculation must be done in (pretty much) one way there may be repeated loads from memory: operands are trapped on the stack On a general-purpose register architecture: the calculation can be done in many ways 14
15 General-Purpose Register (GPR) Architectures GPR trends: more registers more general-purpose registers Why? uniform model for compilers makes possible more compiler optimisations (compiler decides how to make best use of registers) 15
16 GPR: Register-Memory Architectures GPR-RM: CISC is typical of this architecture memory addressing for all/many ALU instructions (usually) complex addressing modes Example: Load R1,A Add R3,R1,B // mixed register/memory addressing Store R3,C 16
17 GPR-RM Diagram 17
18 Another Example E=(A*B)+(C*D): Load R1,A Mult R2,R1,B Load R1,C Mult R3,R1,D Add R4,R2,R3 Store R4,E Note Fewer instructions. Compiler is free to use registers as it likes, and frequently re-use register contents. 18
19 An Unexpected Turn At one point: it was expected that ISAs would become increasingly complex it was even thought C might be supported directly in hardware Note All of which turned out to be wrong! 19
20 Why? it turned out we could write very good compilers (so, complexity at the hardware level wasn t needed) RISC ISAs were better suited to hardware opimisation (particularly instruction-level parallelism via pipelining) 20
21 GPR: Register-Register Architecture GPR-RR: all ALU instructions are register-register all memory operations are load/store (usually) fewer addressing modes Example: Load R1,A Load R2,B Add R3,R1,R2 Store R3,C 21
22 GPR-RR Diagram 22
23 Classification Memory Max. Type Examples Addresses Num. of Operands 0 3 Load-Store Alpha, ARM, MIPS, PowerPC, SPARC, 1 2 Register-Memory IBM 360/370, Intel 8086, 2 2 Memory-Memory Vax 3 3 Memory-Memory Vax 23
24 Instruction Size Two approaches: variable-size instructions fixed-size instructions 24
25 Variable-Size Instructions Examples: 8086, VAX, for 8086, instructions vary from 1 to 17 bytes! 25
26 Variable-Size Instructions 8086 Example 26
27 Variable-Size Instructions Considerations: additional bits required to indicate instruction format multiple steps to fetch and decode instructions: fetch first part, workout how long instruction is, fetch rest, inhibits out-of-order execution optimisations short instructions lead to compact code: especially if they are well chosen and frequently occurring 27
28 Fixed-Size Instructions Examples: MIPS, ARM (both 32 bits for all instructions) Considerations: simple/fast fetch/decode cycle simplifies hardware optimisation (pipelining, out-of-order execution) constrains instruction design: for example, the number of bits available to represent displacement and immediate addresses is limited (see anon) 28
29 Variable-Size Instructions MIPS Example 29
30 Memory Addressing Main memory is: a sequence of linearly addressable bytes Bytes Commonly termed 1 bytes 2 half words (sometimes short words) 4 words 8 double words (or, helpfully, sometimes "words") 30
31 Memory Alignment Usually: memory accesses must usually be memory aligned when not, additional costs are incurred (either in hardware or in software) Example: half words can be accessed efficiently only at addresses which are divisible by 2 words can be accessed efficiently only at addresses which are divisible by 4 31
32 Addressing Modes How, in various ISAs, can bytes in memory be addressed? 32
33 Addressing Mode Register Example: Add R4,R3 // Regs[R4] = Regs[R4] + Regs[R3] Typical usage: values needed are already in registers (or must initially be loaded into registers) 33
34 Addressing Mode Immediate Example: Add R4,#123 // Regs[R4] = Regs[R4] Typical usage: constants 34
35 Addressing Example Example: // Assume i is in a register, say R4 i = i + 123; 35
36 Addressing Mode Displacement Example: Add R4,100(R1) // Regs[R4] = Regs[R4] + Mem[Regs[R1]+100] Typical usage: parameters, local variables (e.g. offset within current stack frame) instance variables (Java) (e.g. offset from address of object) static index into array (e.g. offset from base of array, A[1]) 36
37 Addressing Example Example: Add R4,100(R1) // Regs[R4] = Regs[R4] + Mem[Regs[R1]+100] Example: int func(char *str, int n) { int i = 0; // assume that i is in a register, say R4 // and that R1 is the stack pointer; then // n is at a known offset from R1 i = i + n; } 37
38 Addressing Example Example: Add R4,100(R1) // Regs[R4] = Regs[R4] + Mem[Regs[R1]+100] Example: class Something { String some_string = "Whatever"; int value = 7; } void add_value(int n) { // assume that n is in a register, say R4 // and that R1 is the address of the object; // then value is at a known offset from R1 return n + value; } 38
39 Addressing Mode Register Indirect Example: Add R4,(R1) // Regs[R4] = Regs[R4] + Mem[Regs[R1]] Typical usage: access using a pointer, or a computed memory address special case of displacement addressing (displacement is 0) 39
40 Addressing Mode Indexed Example: Add R4,(R1 + R2) // Regs[R4] = Regs[R4] + Mem[Regs[R1]+Regs[R2]] Typical usage: index into an array (e.g. R1 might contain the base of the array, R2 the offset) 40
41 Addressing Example Example: char vs[] = { 87, 56, 90, 1, 56 }; int total = 0, index = 3; // assume total is in R4 // vs is in R1 // index is in R2 total = total + vs[index]; 41
42 Addressing Mode Direct (or Absolute) Example: Add R4,(120096) // Regs[R4] = Regs[R4] + Mem[120096] Typical usage: accessing static data address constant may need to be large (c.f. limitations on sizes of immediates in fixed-sized instructions) another special case of displacement addressing (the register value is 0) 42
43 Addressing Example Example: static int n = 123; int something() { int i = 7896; } // assume i is in R4 i = i + n; The address of n is (well, it might be) known at compile time. Note Warning: 43
44 This example may not be valid; for example, if the code is position independent. 44
45 Addressing Mode Memory Indirect Example: Add // Regs[R4] = Regs[R4] + Mem[Mem[Regs[R3]]] Typical usage: pointer chasing 45
46 Addressing Example Example: struct { int *ip; } thing; void something() { int tot = 0; // assume tot is in R4 } // assume address of thing is in R3 tot = tot + *(thing->ip); Note Warning: This is a pretty strange example. 46
47 Addressing Mode Autoincrement (or Decrement) Example: Add R4,100(R1) // Regs[R4] = Regs[R4] + Mem[Regs[R1]] // Regs[R1] = Regs[R1] + d // where d is the data size of the access Typical usage: step through arrays (where size of element is d) like register indirect, but with a side effect Note Autodecrement is the same, just with subtraction. 47
48 Addressing Example Example: int a[100]; int i, tot; // assume tot is in R4 // assume address of a[0] is in R1 for (i=0; i<100; i+=1) tot = tot + a[i]; 48
49 Addressing Mode Scaled Example: Add R1,100(R2)[R3] // Regs[R4] = // Regs[R4] + Mem[ Regs[R2] + Regs[R3]*d ] // where d is the data size of the access Typical usage: index into arrays (e.g. R2 might contain the base of the array, R3 the index) 49
50 Addressing Example Example: struct { int x; int y; } a[100]; int i, tot; // assume tot is in R4 // assume the base address of a is in R2 // assume i is in R3 // d is 2*sizeof(int), which may be 8 for (i=0; i<100; i+=1) tot = tot + a[i].x; 50
51 Frequency of Use The addressing modes used in practice are determined by: compilers application characteristics 51
52 Frequency of Use in Practice 52
53 Obviously: we should worry most about the most frequently-occurring modes 53
54 MIPS ALU operations: register addressing only (it s a RISC architecture) Loads and stores: displacement addressing only Mem[Regs[R1]+n] 54
55 MIPS However: displacement addressing can emulate register indirect addressing (just use a displacement of 0) displacement addressing can emulate immediate addressing (just use a register containing the value 0, specifically R0) 55
56 Displacement Addressing (Again) Example: Add R4,100(R1) // Regs[R4] = Regs[R4] + Mem[Regs[R1]+100] Key question: what range of displacements is available? Note This is a major issue for fixed instruction size ISAs like PowerPC, MIPS and ARM. 56
57 MIPS Displacements 57
58 Displacement Addressing Displacements See: here [figures-slidy/picdisplacements.png]. Comments: many displacements are small but a non-negligible number are large, particularly for FP ops most small displacements are positive, most large displacements are negative (these usually refer to different memory segments) (not shown on graph) Note These measurements are from an Alpha machine with 16 bits of displacement available. 58
59 MIPS and PowerPC Immediate values: 16 bits so values from 0 to
60 ARM Immediate values: just 12 bits so values from 0 to 4095 That s not a lot! 60
61 A neat trick of ARM processors An 12-bit ARM immediate value is divided into two parts: 4 bits of rotation 8 bits of immediate value 61
62 The rotation bits 4 bits of rotation: gives 16 possible rotations (of a 32-bit value) This is multiplied by 2 to give: 16 possible rotations for the even values only or rotations of 0 to 30 bits, even values only 62
63 Examples
64 Examples So; while only `2^{12}` values can be encoded the range of possible values is large 64
65 Done <script> (function() { var mathjax = 'mathjax/mathjax.js?config=asciimath'; // var mathjax = ' var element = document.createelement('script'); element.async = true; element.src = mathjax; element.type = 'text/javascript'; (document.getelementsbytagname('head')[0] document.body).appendchild(element); })(); </script> 65
COSC 6385 Computer Architecture. Instruction Set Architectures
COSC 6385 Computer Architecture Instruction Set Architectures Spring 2012 Instruction Set Architecture (ISA) Definition on Wikipedia: Part of the Computer Architecture related to programming Defines set
More informationCPU Architecture and Instruction Sets Chapter 1
CPU Architecture and Instruction Sets Chapter 1 1 Is CPU Architecture Relevant for DBMS? CPU design focuses on speed resulting in a 55%/year improvement since 1987: If CPU performance in database code
More informationINSTITUTO SUPERIOR TÉCNICO. Architectures for Embedded Computing
UNIVERSIDADE TÉCNICA DE LISBOA INSTITUTO SUPERIOR TÉCNICO Departamento de Engenharia Informática for Embedded Computing MEIC-A, MEIC-T, MERC Lecture Slides Version 3.0 - English Lecture 03 Title: Processor
More informationInstruction Set Principles and Examples. Appendix B
Instruction Set Principles and Examples Appendix B Outline What is Instruction Set Architecture? Classifying ISA Elements of ISA Programming Registers Type and Size of Operands Addressing Modes Types of
More informationLecture 4: Instruction Set Architecture
Lecture 4: Instruction Set Architecture ISA types, register usage, memory addressing, endian and alignment, quantitative evaluation Reading: Textbook (5 th edition) Appendix A Appendix B (4 th edition)
More informationInstruction Set Architecture. "Speaking with the computer"
Instruction Set Architecture "Speaking with the computer" The Instruction Set Architecture Application Compiler Instr. Set Proc. Operating System I/O system Instruction Set Architecture Digital Design
More informationLecture 3 Machine Language. Instructions: Instruction Execution cycle. Speaking computer before voice recognition interfaces
Lecture 3 Machine Language Speaking computer before voice recognition interfaces 1 Instructions: Language of the Machine More primitive than higher level languages e.g., no sophisticated control flow Very
More informationCA226 Advanced Computer Architecture
Table of Contents Stephen Blott 1 MIPS MIPS is: a RISC instruction-set architecture: all ALU operations are register-register initially 32-bit, later 64-bit Its design is heavily
More informationInstruction Set Architecture (ISA)
Instruction Set Architecture (ISA)... the attributes of a [computing] system as seen by the programmer, i.e. the conceptual structure and functional behavior, as distinct from the organization of the data
More informationLecture 4: Instruction Set Design/Pipelining
Lecture 4: Instruction Set Design/Pipelining Instruction set design (Sections 2.9-2.12) control instructions instruction encoding Basic pipelining implementation (Section A.1) 1 Control Transfer Instructions
More informationPage 1. Structure of von Nuemann machine. Instruction Set - the type of Instructions
Structure of von Nuemann machine Arithmetic and Logic Unit Input Output Equipment Main Memory Program Control Unit 1 1 Instruction Set - the type of Instructions Arithmetic + Logical (ADD, SUB, MULT, DIV,
More informationISA and RISCV. CASS 2018 Lavanya Ramapantulu
ISA and RISCV CASS 2018 Lavanya Ramapantulu Program Program =?? Algorithm + Data Structures Niklaus Wirth Program (Abstraction) of processor/hardware that executes 3-Jul-18 CASS18 - ISA and RISCV 2 Program
More informationCSCE 5610: Computer Architecture
HW #1 1.3, 1.5, 1.9, 1.12 Due: Sept 12, 2018 Review: Execution time of a program Arithmetic Average, Weighted Arithmetic Average Geometric Mean Benchmarks, kernels and synthetic benchmarks Computing CPI
More informationTypical Processor Execution Cycle
Typical Processor Execution Cycle Instruction Fetch Obtain instruction from program storage Instruction Decode Determine required actions and instruction size Operand Fetch Locate and obtain operand data
More informationECE232: Hardware Organization and Design
ECE232: Hardware Organization and Design Lecture 2: Hardware/Software Interface Adapted from Computer Organization and Design, Patterson & Hennessy, UCB Overview Basic computer components How does a microprocessor
More informationInstruction Set Design
Instruction Set Design software instruction set hardware CPE442 Lec 3 ISA.1 Instruction Set Architecture Programmer's View ADD SUBTRACT AND OR COMPARE... 01010 01110 10011 10001 11010... CPU Memory I/O
More informationCA226 Advanced Computer Architecture
Stephen Blott Today: data hazards Table of Contents 1 2 MIPS Pipeline Recall: the MIPS pipeline implements instruction level parallelism ideally, up to five instructions are executed
More informationEvolution of ISAs. Instruction set architectures have changed over computer generations with changes in the
Evolution of ISAs Instruction set architectures have changed over computer generations with changes in the cost of the hardware density of the hardware design philosophy potential performance gains One
More informationCS4617 Computer Architecture
1/27 CS4617 Computer Architecture Lecture 7: Instruction Set Architectures Dr J Vaughan October 1, 2014 2/27 ISA Classification Stack architecture: operands on top of stack Accumulator architecture: 1
More informationCMSC Computer Architecture Lecture 2: ISA. Prof. Yanjing Li Department of Computer Science University of Chicago
CMSC 22200 Computer Architecture Lecture 2: ISA Prof. Yanjing Li Department of Computer Science University of Chicago Administrative Stuff! Lab1 is out! " Due next Thursday (10/6)! Lab2 " Out next Thursday
More informationInstruction Sets Ch 9-10
Instruction Sets Ch 9-10 Characteristics Operands Operations Addressing Instruction Formats 1 Instruction Set (käskykanta) Collection of instructions that CPU understands Only interface to CPU from outside
More informationInstruction Sets Ch 9-10
Instruction Sets Ch 9-10 Characteristics Operands Operations Addressing Instruction Formats 1 Instruction Set (käskykanta) Collection of instructions that CPU understands Only interface to CPU from outside
More informationInstruction Set. Instruction Sets Ch Instruction Representation. Machine Instruction. Instruction Set Design (5) Operation types
Instruction Sets Ch 10-11 Characteristics Operands Operations Addressing Instruction Formats Instruction Set Collection of instructions that CPU understands Only interface to CPU from outside CPU executes
More informationEITF20: Computer Architecture Part2.1.1: Instruction Set Architecture
EITF20: Computer Architecture Part2.1.1: Instruction Set Architecture Liang Liu liang.liu@eit.lth.se 1 Outline Reiteration Instruction Set Principles The Role of Compilers MIPS 2 Main Content Computer
More informationChapter 2. Instruction Set Design. Computer Architectures. software. hardware. Which is easier to change/design??? Tien-Fu Chen
Computer Architectures Chapter 2 Tien-Fu Chen National Chung Cheng Univ. chap2-0 Instruction Set Design software instruction set hardware Which is easier to change/design??? chap2-1 Instruction Set Architecture:
More informationChapter 2: Instructions How we talk to the computer
Chapter 2: Instructions How we talk to the computer 1 The Instruction Set Architecture that part of the architecture that is visible to the programmer - instruction formats - opcodes (available instructions)
More informationComputer Organization CS 206 T Lec# 2: Instruction Sets
Computer Organization CS 206 T Lec# 2: Instruction Sets Topics What is an instruction set Elements of instruction Instruction Format Instruction types Types of operations Types of operand Addressing mode
More information55:132/22C:160, HPCA Spring 2011
55:132/22C:160, HPCA Spring 2011 Second Lecture Slide Set Instruction Set Architecture Instruction Set Architecture ISA, the boundary between software and hardware Specifies the logical machine that is
More informationInstruction Set Architectures
Lecture 2 Instruction Set Architectures Dr. Soner Onder CS 4431 Michigan Technological University 09/04/12 1 Instruction Set Architecture (ISA) 1950s to 1960s: Computer Architecture Course Computer Arithmetic
More informationComputer Architecture
Computer Architecture Lecture 3: ISA Tradeoffs Dr. Ahmed Sallam Suez Canal University Spring 2015 Based on original slides by Prof. Onur Mutlu Design Point A set of design considerations and their importance
More informationComputer Architecture
Computer Architecture Lecture 3: ISA Tradeoffs Dr. Ahmed Sallam Suez Canal University Based on original slides by Prof. Onur Mutlu Application Space Dream, and they will appear 2 Design Point A set of
More informationCHAPTER 5 A Closer Look at Instruction Set Architectures
CHAPTER 5 A Closer Look at Instruction Set Architectures 5.1 Introduction 5.2 Instruction Formats 5.2.1 Design Decisions for Instruction Sets 5.2.2 Little versus Big Endian 5.2.3 Internal Storage in the
More informationINSTITUTO SUPERIOR TÉCNICO. Architectures for Embedded Computing
UNIVERSIDADE TÉCNICA DE LISBOA INSTITUTO SUPERIOR TÉCNICO Departamento de Engenharia Informática Architectures for Embedded Computing MEIC-A, MEIC-T, MERC Lecture Slides Version 3.0 - English Lecture 04
More informationChapter 5. A Closer Look at Instruction Set Architectures. Chapter 5 Objectives. 5.1 Introduction. 5.2 Instruction Formats
Chapter 5 Objectives Understand the factors involved in instruction set architecture design. Chapter 5 A Closer Look at Instruction Set Architectures Gain familiarity with memory addressing modes. Understand
More informationEC-801 Advanced Computer Architecture
EC-801 Advanced Computer Architecture Lecture 5 Instruction Set Architecture I Dr Hashim Ali Fall 2018 Department of Computer Science and Engineering HITEC University Taxila!1 Instruction Set Architecture
More informationECE232: Hardware Organization and Design
ECE232: Hardware Organization and Design Lecture 4: MIPS Instructions Adapted from Computer Organization and Design, Patterson & Hennessy, UCB From Last Time Two values enter from the left (A and B) Need
More informationChapter 5. A Closer Look at Instruction Set Architectures
Chapter 5 A Closer Look at Instruction Set Architectures Chapter 5 Objectives Understand the factors involved in instruction set architecture design. Gain familiarity with memory addressing modes. Understand
More informationHakim Weatherspoon CS 3410 Computer Science Cornell University
Hakim Weatherspoon CS 3410 Computer Science Cornell University The slides are the product of many rounds of teaching CS 3410 by Professors Weatherspoon, Bala, Bracy, McKee, and Sirer. Prelim today Starts
More informationInstruction Set Architectures. Part 1
Instruction Set Architectures Part 1 Application Compiler Instr. Set Proc. Operating System I/O system Instruction Set Architecture Digital Design Circuit Design 1/9/02 Some ancient history Earliest (1940
More informationECE 486/586. Computer Architecture. Lecture # 7
ECE 486/586 Computer Architecture Lecture # 7 Spring 2015 Portland State University Lecture Topics Instruction Set Principles Instruction Encoding Role of Compilers The MIPS Architecture Reference: Appendix
More informationInstruction Set (ISA) Design and Addressing Modes
3-1 3-1 Instruction Set (ISA) Design and Addressing Modes Material from sections 2.1, 2.2, and 2.3. Outline ISA Design Choices It s more than just picking instructions. ISA Design Choice Details Screw
More informationCOSC 6385 Computer Architecture - Instruction Set Principles
COSC 6385 Computer rchitecture - Instruction Set Principles Fall 2006 Organizational Issues September 4th: no class (labor day holiday) Classes of onday Sept. 11 th and Wednesday Sept. 13 th have to be
More informationLecture 5: Instruction Set Architectures II. Take QUIZ 2 before 11:59pm today over Chapter 1 Quiz 1: 100% - 29; 80% - 25; 60% - 17; 40% - 3
Lecture 5: Instruction Set Architectures II Announcements Turn in Homework #1 XSPIM tutorials in PAI 5.38 during TA office hours Tue Feb 2: 2-3:30pm Wed Feb 3: 1:30-3pm Thu Feb 4: 3-4:30pm Take QUIZ 2
More informationCA226 Advanced Computer Architecture
Stephen Blott Review of MIPS Instruction Set Table of Contents 1 2 Registers Memory Instructions r0 ; always 0 r1, r2,..., r31 ; general-purpose integer registers f0, f1, f2,...,
More informationChapter 2 Instruction: Language of the Computer
Chapter 2 Instruction: Language of the Computer 1 Table of Contents Ch.1 Introduction Ch. 2 Instruction: Machine Language Ch. 3-4 CPU Implementation Ch. 5 Cache and VM Ch. 6-7 I/O & Multiprocessors Computer
More informationCPE 631 Lecture 08: Virtual Memory
Lecture 08: Virtual Virtual : Topics Why virtual memory? Virtual to physical address translation Page Table Translation Lookaside Buffer (TLB) Aleksandar Milenković, milenka@ece.uah.edu Electrical and
More informationRISC, CISC, and ISA Variations
RISC, CISC, and ISA Variations CS 3410 Computer System Organization & Programming These slides are the product of many rounds of teaching CS 3410 by Professors Weatherspoon, Bala, Bracy, and Sirer. iclicker
More informationChapter 5. A Closer Look at Instruction Set Architectures
Chapter 5 A Closer Look at Instruction Set Architectures Chapter 5 Objectives Understand the factors involved in instruction set architecture design. Gain familiarity with memory addressing modes. Understand
More informationOutline. What Makes a Good ISA? Programmability. Implementability. Programmability Easy to express programs efficiently?
Outline Instruction Sets in General MIPS Assembly Programming Other Instruction Sets Goals of ISA Design RISC vs. CISC Intel x86 (IA-32) What Makes a Good ISA? Programmability Easy to express programs
More informationChapter 11. Instruction Sets: Addressing Modes and Formats. Yonsei University
Chapter 11 Instruction Sets: Addressing Modes and Formats Contents Addressing Pentium and PowerPC Addressing Modes Instruction Formats Pentium and PowerPC Instruction Formats 11-2 Common Addressing Techniques
More informationECE 486/586. Computer Architecture. Lecture # 8
ECE 486/586 Computer Architecture Lecture # 8 Spring 2015 Portland State University Lecture Topics Instruction Set Principles MIPS Control flow instructions Dealing with constants IA-32 Fallacies and Pitfalls
More informationCS/ECE/752 Chapter 2 Instruction Sets Instructor: Prof. Wood
CS/ECE/752 Chapter 2 Instruction Sets Instructor: Prof. Wood Computer Sciences Department University of Wisconsin Slides developed by Profs. Falsafi,, Hill, Smith, Sohi,, and Vijaykumar of Carnegie Mellon
More informationEITF20: Computer Architecture Part2.1.1: Instruction Set Architecture
EITF20: Computer Architecture Part2.1.1: Instruction Set Architecture Liang Liu liang.liu@eit.lth.se 1 Outline Reiteration Instruction Set Principles The Role of Compilers MIPS 2 Main Content Computer
More informationCHAPTER 5 A Closer Look at Instruction Set Architectures
CHAPTER 5 A Closer Look at Instruction Set Architectures 5.1 Introduction 199 5.2 Instruction Formats 199 5.2.1 Design Decisions for Instruction Sets 200 5.2.2 Little versus Big Endian 201 5.2.3 Internal
More informationChapter 2A Instructions: Language of the Computer
Chapter 2A Instructions: Language of the Computer Copyright 2009 Elsevier, Inc. All rights reserved. Instruction Set The repertoire of instructions of a computer Different computers have different instruction
More informationGraduate Computer Architecture. Chapter 2. Instruction Set Principles
Graduate Computer Architecture Chapter 2 Instruction Set Principles 1 Outline Classifying instruction set architectures Memory addressing Addressing modes Type and size of operands Instructions for control
More informationLecture Topics. Branch Condition Options. Branch Conditions ECE 486/586. Computer Architecture. Lecture # 8. Instruction Set Principles.
ECE 486/586 Computer Architecture Lecture # 8 Spring 2015 Portland State University Instruction Set Principles MIPS Control flow instructions Dealing with constants IA-32 Fallacies and Pitfalls Reference:
More informationCSCI 402: Computer Architectures. Instructions: Language of the Computer (1) Fengguang Song Department of Computer & Information Science IUPUI
To study Chapter 2: CSCI 402: Computer Architectures Instructions: Language of the Computer (1) Fengguang Song Department of Computer & Information Science IUPUI Contents 2.1-2.3 Introduction to what is
More informationComputer Organization MIPS ISA
CPE 335 Computer Organization MIPS ISA Dr. Iyad Jafar Adapted from Dr. Gheith Abandah Slides http://www.abandah.com/gheith/courses/cpe335_s08/index.html CPE 232 MIPS ISA 1 (vonneumann) Processor Organization
More informationLecture 4: RISC Computers
Lecture 4: RISC Computers Introduction Program execution features RISC characteristics RISC vs. CICS Zebo Peng, IDA, LiTH 1 Introduction Reduced Instruction Set Computer (RISC) represents an important
More informationCHAPTER 5 A Closer Look at Instruction Set Architectures
CHAPTER 5 A Closer Look at Instruction Set Architectures 5.1 Introduction 293 5.2 Instruction Formats 293 5.2.1 Design Decisions for Instruction Sets 294 5.2.2 Little versus Big Endian 295 5.2.3 Internal
More informationRISC Principles. Introduction
3 RISC Principles In the last chapter, we presented many details on the processor design space as well as the CISC and RISC architectures. It is time we consolidated our discussion to give details of RISC
More informationInstruction-set Design Issues: what is the ML instruction format(s) ML instruction Opcode Dest. Operand Source Operand 1...
Instruction-set Design Issues: what is the format(s) Opcode Dest. Operand Source Operand 1... 1) Which instructions to include: How many? Complexity - simple ADD R1, R2, R3 complex e.g., VAX MATCHC substrlength,
More informationProf. Hakim Weatherspoon CS 3410, Spring 2015 Computer Science Cornell University. See P&H Appendix , and 2.21
Prof. Hakim Weatherspoon CS 3410, Spring 2015 Computer Science Cornell University See P&H Appendix 2.16 2.18, and 2.21 There is a Lab Section this week, C Lab2 Project1 (PA1) is due next Monday, March
More informationINSTRUCTION SET ARCHITECTURE
INSTRUCTION SET ARCHITECTURE Slides by: Pedro Tomás Additional reading: Computer Architecture: A Quantitative Approach, 5th edition, Appendix A, John L. Hennessy and David A. Patterson, Morgan Kaufmann,
More informationInstruction-set Design Issues: what is the ML instruction format(s) ML instruction Opcode Dest. Operand Source Operand 1...
Instruction-set Design Issues: what is the format(s) Opcode Dest. Operand Source Operand 1... 1) Which instructions to include: How many? Complexity - simple ADD R1, R2, R3 complex e.g., VAX MATCHC substrlength,
More informationUnderstand the factors involved in instruction set
A Closer Look at Instruction Set Architectures Objectives Understand the factors involved in instruction set architecture design. Look at different instruction formats, operand types, and memory access
More informationCOSC 6385 Computer Architecture. Defining Computer Architecture
COSC 6385 Computer rchitecture Defining Computer rchitecture Fall 007 icro-processors in today s world arkets Desktop computing Servers Embedded computers Characteristics Price vailability Reliability
More informationLecture 4: ISA Tradeoffs (Continued) and Single-Cycle Microarchitectures
Lecture 4: ISA Tradeoffs (Continued) and Single-Cycle Microarchitectures ISA-level Tradeoffs: Instruction Length Fixed length: Length of all instructions the same + Easier to decode single instruction
More informationOutline. What Makes a Good ISA? Programmability. Implementability
Outline Instruction Sets in General MIPS Assembly Programming Other Instruction Sets Goals of ISA Design RISC vs. CISC Intel x86 (IA-32) What Makes a Good ISA? Programmability Easy to express programs
More informationRISC & Superscalar. COMP 212 Computer Organization & Architecture. COMP 212 Fall Lecture 12. Instruction Pipeline no hazard.
COMP 212 Computer Organization & Architecture Pipeline Re-Cap Pipeline is ILP -Instruction Level Parallelism COMP 212 Fall 2008 Lecture 12 RISC & Superscalar Divide instruction cycles into stages, overlapped
More informationChapter 5. A Closer Look at Instruction Set Architectures
Chapter 5 A Closer Look at Instruction Set Architectures Chapter 5 Objectives Understand the factors involved in instruction set architecture design. Gain familiarity with memory addressing modes. Understand
More informationCHAPTER 2: INSTRUCTION SET PRINCIPLES. Prepared by Mdm Rohaya binti Abu Hassan
CHAPTER 2: INSTRUCTION SET PRINCIPLES Prepared by Mdm Rohaya binti Abu Hassan Chapter 2: Instruction Set Principles Instruction Set Architecture Classification of ISA/Types of machine Primary advantages
More informationChapter 5. A Closer Look at Instruction Set Architectures. Chapter 5 Objectives. 5.1 Introduction. 5.2 Instruction Formats
Chapter 5 Objectives Chapter 5 A Closer Look at Instruction Set Architectures Understand the factors involved in instruction set architecture design. Gain familiarity with memory addressing modes. Understand
More informationEC 413 Computer Organization
EC 413 Computer Organization Review I Prof. Michel A. Kinsy Computing: The Art of Abstraction Application Algorithm Programming Language Operating System/Virtual Machine Instruction Set Architecture (ISA)
More informationInstruction Sets: Characteristics and Functions Addressing Modes
Instruction Sets: Characteristics and Functions Addressing Modes Chapters 10 and 11, William Stallings Computer Organization and Architecture 7 th Edition What is an Instruction Set? The complete collection
More informationComputer Architecture and Organization. Instruction Sets: Addressing Modes and Formats
Computer Architecture and Organization Instruction Sets: Addressing Modes and Formats Addressing Modes Immediate Direct Indirect Register Register Indirect Displacement (Indexed) Stack Immediate Addressing
More informationCSIS1120A. 10. Instruction Set & Addressing Mode. CSIS1120A 10. Instruction Set & Addressing Mode 1
CSIS1120A 10. Instruction Set & Addressing Mode CSIS1120A 10. Instruction Set & Addressing Mode 1 Elements of a Machine Instruction Operation Code specifies the operation to be performed, e.g. ADD, SUB
More informationCSE 141 Computer Architecture Spring Lecture 3 Instruction Set Architecute. Course Schedule. Announcements
CSE141: Introduction to Computer Architecture CSE 141 Computer Architecture Spring 2005 Lecture 3 Instruction Set Architecute Pramod V. Argade April 4, 2005 Instructor: TAs: Pramod V. Argade (p2argade@cs.ucsd.edu)
More informationISA: The Hardware Software Interface
ISA: The Hardware Software Interface Instruction Set Architecture (ISA) is where software meets hardware In embedded systems, this boundary is often flexible Understanding of ISA design is therefore important
More informationComputer Architecture
CS3350B Computer Architecture Winter 2015 Lecture 4.2: MIPS ISA -- Instruction Representation Marc Moreno Maza www.csd.uwo.ca/courses/cs3350b [Adapted from lectures on Computer Organization and Design,
More informationWilliam Stallings Computer Organization and Architecture 8 th Edition. Chapter 11 Instruction Sets: Addressing Modes and Formats
William Stallings Computer Organization and Architecture 8 th Edition Chapter 11 Instruction Sets: Addressing Modes and Formats Addressing Modes Immediate Direct Indirect Register Register Indirect Displacement
More informationInstruction Set II. COMP 212 Computer Organization & Architecture. COMP 212 Fall Lecture 7. Instruction Set. Quiz. What is an Instruction Set?
COMP 212 Computer Organization & Architecture Quiz COMP 212 Fall 2008 Lecture 7 Fill in your student number only, do NOT write down your name Open book, but NO calculator, NO discussions, Relax and have
More informationAnnouncements HW1 is due on this Friday (Sept 12th) Appendix A is very helpful to HW1. Check out system calls
Announcements HW1 is due on this Friday (Sept 12 th ) Appendix A is very helpful to HW1. Check out system calls on Page A-48. Ask TA (Liquan chen: liquan@ece.rutgers.edu) about homework related questions.
More informationChapter 13 Reduced Instruction Set Computers
Chapter 13 Reduced Instruction Set Computers Contents Instruction execution characteristics Use of a large register file Compiler-based register optimization Reduced instruction set architecture RISC pipelining
More informationThe von Neumann Architecture. IT 3123 Hardware and Software Concepts. The Instruction Cycle. Registers. LMC Executes a Store.
IT 3123 Hardware and Software Concepts February 11 and Memory II Copyright 2005 by Bob Brown The von Neumann Architecture 00 01 02 03 PC IR Control Unit Command Memory ALU 96 97 98 99 Notice: This session
More informationPractical Malware Analysis
Practical Malware Analysis Ch 4: A Crash Course in x86 Disassembly Revised 1-16-7 Basic Techniques Basic static analysis Looks at malware from the outside Basic dynamic analysis Only shows you how the
More informationCOMPUTER ORGANIZATION & ARCHITECTURE
COMPUTER ORGANIZATION & ARCHITECTURE Instructions Sets Architecture Lesson 5a 1 What are Instruction Sets The complete collection of instructions that are understood by a CPU Can be considered as a functional
More informationChapter 5. A Closer Look at Instruction Set Architectures
Chapter 5 A Closer Look at Instruction Set Architectures Chapter 5 Objectives Understand the factors involved in instruction set architecture design. Gain familiarity with memory addressing modes. Understand
More informationREDUCED INSTRUCTION SET COMPUTERS (RISC)
Datorarkitektur Fö 5/6-1 Datorarkitektur Fö 5/6-2 What are RISCs and why do we need them? REDUCED INSTRUCTION SET COMPUTERS (RISC) RISC architectures represent an important innovation in the area of computer
More informationSlides for Lecture 6
Slides for Lecture 6 ENCM 501: Principles of Computer Architecture Winter 2014 Term Steve Norman, PhD, PEng Electrical & Computer Engineering Schulich School of Engineering University of Calgary 28 January,
More informationComputer Architecture. MIPS Instruction Set Architecture
Computer Architecture MIPS Instruction Set Architecture Instruction Set Architecture An Abstract Data Type Objects Registers & Memory Operations Instructions Goal of Instruction Set Architecture Design
More informationComputer Systems Architecture I. CSE 560M Lecture 3 Prof. Patrick Crowley
Computer Systems Architecture I CSE 560M Lecture 3 Prof. Patrick Crowley Plan for Today Announcements Readings are extremely important! No class meeting next Monday Questions Commentaries A few remaining
More informationComplex Instruction Sets
Complex Instruction Sets CSE 410, Spring 2004 Computer Systems http://www.cs.washington.edu/education/courses/410/04sp/ 5-May-2004 cse410-16-cisc 2004 University of Washington 1 Reading Readings and References»
More informationWe briefly explain an instruction cycle now, before proceeding with the details of addressing modes.
Addressing Modes This is an important feature of computers. We start with the known fact that many instructions have to include addresses; the instructions should be short, but addresses tend to be long.
More informationChapter 2. lw $s1,100($s2) $s1 = Memory[$s2+100] sw $s1,100($s2) Memory[$s2+100] = $s1
Chapter 2 1 MIPS Instructions Instruction Meaning add $s1,$s2,$s3 $s1 = $s2 + $s3 sub $s1,$s2,$s3 $s1 = $s2 $s3 addi $s1,$s2,4 $s1 = $s2 + 4 ori $s1,$s2,4 $s2 = $s2 4 lw $s1,100($s2) $s1 = Memory[$s2+100]
More informationChapter 2 Instruction Set Principles and Examples
EEF011 Computer Architecture 計算機結構 Chapter 2 Instruction Set Principles and Examples 吳俊興高雄大學資訊工程學系 October 2004 Chapter 2. Instruction Set Principles and Examples 2.1 Introduction 2.2 Classifying Instruction
More informationCSCI 402: Computer Architectures. Instructions: Language of the Computer (1) Fengguang Song Department of Computer & Information Science IUPUI
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?
More informationInstruction Set Principles. (Appendix B)
Instruction Set Principles (Appendix B) Outline Introduction Classification of Instruction Set Architectures Addressing Modes Instruction Set Operations Type & Size of Operands Instruction Set Encoding
More informationFrom CISC to RISC. CISC Creates the Anti CISC Revolution. RISC "Philosophy" CISC Limitations
1 CISC Creates the Anti CISC Revolution Digital Equipment Company (DEC) introduces VAX (1977) Commercially successful 32-bit CISC minicomputer From CISC to RISC In 1970s and 1980s CISC minicomputers became
More information