E0-243: Computer Architecture
|
|
- Bryce Hudson
- 6 years ago
- Views:
Transcription
1 E0-243: Computer Architecture L1 ILP Processors RG:E0243:L1-ILP Processors 1
2 ILP Architectures Superscalar Architecture VLIW Architecture EPIC, Subword Parallelism, RG:E0243:L1-ILP Processors 2
3 Motivation for ILP How to achieve an CPI < 1? Exploit Instruction Level Parallelism (ILP) Multiple Instruction Issue and execution Superscalar and VLIW architectures Run-time vs. Compile-time approach. Must maintain sequential specification, although removes non-essential sequentiality and achieves parallel execution where possible. RG:E0243:L1-ILP Processors 3
4 Instruction-Level Parallelism Very Long Instruction Word (VLIW) Architecture Multiple operations per instruction packed at Compile time Compiler/Programmer responsibility to expose ILP Less hardware complexity Examples: Cydra, Multi-Flow, TI-C6x, Trimedia. Superpipelining: stages of the pipeline are further pipelined. Results in deep pipelines and faster clocks. RG:E0243:L1-ILP Processors 4
5 Introduction (contd.) Superscalar Architecture Multiple instructions are fetched, decoded, issued and executed each cycle. Hardware detection of which instructions can be executed in parallel in a cycle at run-time. In-order vs. Out-of-Order Issue Examples: Most modern processors are superpipelined, superscalar architectures: DEC 21x64, MIPS R-8000, R-10000, PA- RISC, PowerPC-620, Pentium, UltraSparc I, II, etc. RG:E0243:L1-ILP Processors 5
6 RG:E0243:L1-ILP Processors 6 Comparison Pipelined IF WB MEM EX ID IF WB MEM EX ID IF WB MEM EX ID Superpipelined Superscalar IF WB MEM EX ID IF WB MEM EX ID IF WB MEM EX ID IF WB MEM EX ID VLIW IF WB MEM EX ID EX IF WB MEM EX ID EX
7 Pipeline Stages Fetch Instruction Buffer Decode Dispatch Buffer Dispatch Issuing Buffer Execute Completion Buffer Complete Store Buffer Retire Source: M. U Wisc.
8 Superscalar Pipeline Stages Fetch Instruction/Decode Buffer Decode Dispatch Buffer Dispatch Issue Branch Reservation Stations Execute Finish Complete Reorder/ Completion Buffer Retire Store Buffer Source: M. U Wisc.
9 Superscalar Execution Model Static Program Fetch & Decode Instrn. Dispatch Instrn. Issue Instrn. Execution Instrn. reorder & commit Instrn. Window True Data Dependency RG:E0243:L1-ILP Processors 9
10 Microarchitecture Overview Mem. interface Predecode Instrn. Cache Instrn. Buffer Decode, Rename & dispatch Instrn. Queues Int. FUs FP. FUs Branch Pred. Reg. File Reorder Buffer RG:E0243:L1-ILP Processors 10
11 IBM Power4 Diversified Pipelines I-Cache PC Fetch Q BR Scan Decode BR Predict FP Issue Q FX/LD 1 Issue Q FX/LD 2 Issue Q BR/CR Issue Q Reorder Buffer FP1 Unit FP2 Unit FX1 Unit LD1 Unit LD2 Unit FX2 Unit CR Unit BR Unit StQ D-Cache Source: M. U Wisc.
12 Impediments to High IPC I-cache Branch Predictor FETCH Instruction Buffer Instruction Flow DECODE Integer Floating-point Media Memory Register Data Flow Reorder Buffer (ROB) Store Queue EXECUTE COMMIT D-cache Memory Data Flow 12 Source: M. U Wisc.
13 MIPS R10000 Issue Queues Source: M. U Wisc.
14 R Characteristics 298 mm 2, 0.35 mm, 6.8 M transistors (2.4M CPU + 4.4M Cache) Fetches and decodes 4 instrns. every cycle. Out-of-order execution. 5 Fus Non-block load/store unit 2 Integer Unit 1 FP Adder, and 1 FP mult. 32K I$ + 32K D$ (2-way associative). External 2-way L2 $ (128-bit sync. Bus) Branch prediction: 512 entry 2-bit BHT. Speculative execution upto 4 pending branches. RG:E0243:L1-ILP Processors 14
15 Instruction Fetch Multiple instructions are fetched from I-Cache into Instrn. Buffer. E.G., R10K fetches 4 instrns. (word aligned) within a 16-word I-Cache line. Fetch bandwidth might be lower due to Branch instrn. in the fetched instrns. Instrn. fetch starting from the middle of a cache line I-Cache miss RG:E0243:L1-ILP Processors 15
16 MIPS R10000 Instruction Fetch RG:E0243:L1-ILP Processors 16
17 Branch Prediction Branch prediction Predecode logic to identify branch instrns. early Branch prediction (through Branch History Table) using PC value (and previous pattern history) R10K has 512-entry 2-bit BHT to support speculative execution upto 4 pending branches. Speculatively execute past multiple pending branches. Branch stack to save alternate branch addr. and Int. and FP reg. remap tables. 4-bit branch mask with each speculatively executed instrn. When a branch is detected to be speculated wrong, all instrns. with corpg. branch mask bit set are squashed. RG:E0243:L1-ILP Processors 17
18 Superpipelined Superscalar Active List Free List A-Calc TLB& Cache Tag Check Write Back IF-1 IF-2 Decode Remap Issue Reg. Read Int. ALU Write Bak Align Add Align Write Back RG:E0243:L1-ILP Processors 18
19 Register Data Dependences Program data dependences cause hazards True dependences (RAW) Antidependences (WAR) Output dependences (WAW) WAW r3 r7 RAW dependency must for correctness WAR WAR and WAW dependencies false dependencies can be eliminated : register renaming RAW r8 load (r3) r3 r3 + 4 Source: M. U Wisc.
20 Instruction Decode Decodes instructions from Instrn. Buffer. Detection of RAW hazards and elimination of WAR and WAR hazards through Dynamic Register Renaming WAR and WAW hazards occur due to reuse of registers. Limited logical registers - e.g., 32 Int. and 32 FP Registers. Available Physical registers/storage is higher. Replace the logical destination register with a free Physical register; any subsequent instrn. which use the value uses the Physical register/storage location. RG:E0243:L1-ILP Processors 20
21 Register Renaming Example: mult r2 r4, r5 add r8 r2, r4 sub r4 r1, r6 div r2 r19, r20 WAR dependency. sub cannot proceed for execution until add reads r4 Using Physical Registers rename WAR and WAW dependences (name dependences) mult R2 R4, R5 add R8 R2, R4 sub R14 R1, R6 div R25 R19, R20 WAR and WAW can be eliminated using Register Renaming. WAW dependency. Div cannot proceed for execution until mult completes exec. RG:E0243:L1-ILP Processors 21
22 Register Renaming Using Physical Registers (size equals twice the no. of logical registers) A register map table which maintains the association betn. logical and physical registers Free list maintains available free regs. Each source operand reg. is replaced by corpg. Physical reg. Each destn. reg. (logical) is assigned a free physical register. Physical reg. is reclaimed after all use of the value Before Add r3 r3, r4 - r0 r1 r2 r3 r4 R8 R7 R5 R1 R9 R2, R6, R13 Free list r0 r1 r2 r3 r4 After Add R2 R1, R9 R8 R7 R5 R2 R9 R6, R13 Free list A Reorder Buffer (ROB) stores instrns. in program order (for inorder completion) Example: MIPS 10k/12k, DEC RG:E0243:L1-ILP Processors 22
23 Register Renaming in R10000 Unit FLTX fs ft fr fd MADD 16 read ports + 4 write ports R FP Map R R W R FP Free Reg. List Br. mask Unit FP Instn. Queue FP busy FLTX Rdy OpA OpB OpC Dst. Active List Log Dst. Renaming complexity proportional to IW Renaming delay proportional to IW. D W Tag R Exc CC Old Dst. RG:E0243:L1-ILP Processors 23
24 Alternative Register Renaming Using Reorder Buffer as temporary storage for speculated values. No. of Physical Regs. = No. of Logical Regs. Each destn. reg. is assigned entries in the tail of the ROB. Upon instrn. execution result values are written in ROB. When the instrn. reaches the head of ROB, the value is written in physical (same as logical) reg. Source operands are read from ROB entry or register as indicated by the register map table. Before Add r3 r3, r4 r0 r1 r2 r3 r4 7 6 r3 Map table r0 r1 r2 rob6 r4 Reorder Buffer 0 After Add r3 rob6, r4 rob8 Example: Pentium Pro, HP-PA8000, Power-PC 604, SPARC64 RG:E0243:L1-ILP Processors 24 r0 r1 r2 r3 r4 8 r3 Map table r0 r1 r2 rob8 rob6 r4 7 6 r3 Reorder Buffer 0
25 Superpipelined Superscalar Active List Free List A-Calc TLB& Cache Tag Check Write Back IF-1 IF-2 Decode Remap Issue Reg. Read Int. ALU Write Bak Align Add Align Write Back RG:E0243:L1-ILP Processors 25
26 In-order vs. Out-of-Order RAW Stalls Stalls Stalls In-order Issue load R2 <-- M(R3) mult R6 <- R4, R2 sub R8 <- R6, R1 store M(R9) <- R8 add R3 <- R3, 4 add R9 <- R9, 4 proceeds to FU for exec. Stalls Stalls Out-of-Order Issue load R2 <-- M(R3) mult R6 <- R4, R2 sub R8 <- R6, R1 store M(R9) <- R8 add R3 <- R3, 4 add R9 <- R9, 4 Example: MIPS-8000, SPARC, DEC 21064, Example: MIPS-10000, PowerPC620, DEC RG:E0243:L1-ILP Processors 26
27 Instruction Dispatch & Issue Decoded and renamed instns. are dispatched to Instruction Queues Single instrn. queue for all instrn. types (typically in inorder issue processors!) Different queues for each instrn. type (e.g., Integer, FP, and Load/Store) -- typically in out-of-order issue processors! or Reservation stations for each each FU or FU type (typically for out-of-order issue processors) From despatch From despatch From despatch to Fus Ld/St Unit Int. Units FP Units Ld/St Unit Int. Units FP Units RG:E0243:L1-ILP Processors 27
28 Instruction Issue: Wakeup & Select Instrn. Issue: waits in instrn. queue/ reservation station for data dependences to be satisfied (check for ready bits in the Instrn. Queue/Res. Station entry). resource (Functional Unit) to be available. Instruction Select: Among the ready instrns., a subset is selected (based on priority ) to be issued to the FUs. RG:E0243:L1-ILP Processors 28
29 Priority Logic Wakeup & Select in R10000 Dest.1,2,3 Dest.1,2,3 Dest.1,2,3,4 Br. Verify = = = = = = = = = = Func. Immed. Br. Mask Tag OpA Ry OpB Ry OpC Dst. Ry RG:E0243:L1-ILP Processors 29
30 Dependence Checking Dest Src0 Src1 Dest Src0 Src1 Dest Src0 Src1 Dest Src0 Src1?=?=?=?=?=?=?=?=?=?=?=?= Trailing instructions in fetch group Check for dependence on leading instructions Source: M. U Wisc.
31 Wakeup & Select Wakeup phase of the issue stage : The Result tag from the completing instructions is broadcast to all waiting instructions. All instructions compare all tags and set ready bits appropriately. Typically implemented as a CAM Wakeup logic complexity proportional to Instrn. Window size and Issue width. Select phase of the issue stage : Choose all or some of the ready instructions for execution depending on age and EU availability. Selection logic complexity proportional to WS Challenges The wakeup and select phases cannot be pipelined. Broadcast latency grows quadratically with issue queue and issue width. RG:E0243:L1-ILP Processors 31
32 Instn. Issue & Execution in R10000 Int. Instrn. Queue Register File Reorder Buffer ALU-2 Result Bypass ALU-1 Result Int. FU RG:E0243:L1-ILP Processors 32
33 Bypass Logic Bypass results from the earliest stage in FU where it is avalable. S stages betn. resultproducing to resultwriting. Bypass results from all FUs (of the same type) to all oprnds. of all FUs. for S cycles. Complexity a IW 2 xs. F U WB1 Buff. WB2 RG:E0243:L1-ILP Processors 33
34 Superpipelined Superscalar Active List Free List A-Calc TLB& Cache Tag Check Write Back IF-1 IF-2 Decode Remap Issue Reg. Read Int. ALU Write Bak Align Add Align Write Back RG:E0243:L1-ILP Processors 34
35 Addr. Instrn. Queue Load/Store Queue Memory ops. involve address calculation and translation use of TLB for translation. Load/Store queue is typically FIFO to ensure load/stores dependences in out-of-order execution. Store M(r8) r3 load Dependent on store or not? r6 M (r16) Addr. calculation & translation Store Load Load buffer Addr. compare Memory renaming (unlike reg. renaming) is difficult. Store buffer To memory RG:E0243:L1-ILP Processors 35
36 Commit Stage To maintain appearance of sequential exec. in speculative and out-of-order execution. To maintain precise interrupts. Typically, instructions are committed in program order (from Reorder Buffer) In case of branch misprediction, speculative executed instrns. and their effects are annulled by reloading the register map table (saved on branch prediction) In physical reg. renaming, restoring reg. map table suffices. squashing a part of the Reorder Buffer (if ROB is used for register renaming) Memory Consistency (Reading) Shared Memory Consistency Models: A Tutorial, S. Adve and K. Gharachorloo, IEEE Computer, 1995 RG:E0243:L1-ILP Processors 36
37 Microarchitecture Overview Mem. interface Predecode Instrn. Cache Instrn. Buffer Decode, Rename & dispatch Instrn. Queues Int. FUs FP. FUs Branch Pred. Reg. File Reorder Buffer RG:E0243:L1-ILP Processors 37
38 Recall: Register Renaming in R10000 Unit FLTX fs ft fr fd MADD 16 read ports + 4 write ports R FP Map R R W R FP Free Reg. List Br. mask Unit FP Instn. Queue FP busy FLTX Rdy OpA OpB OpC Dst. Active List Log Dst. Renaming complexity proportional to IW Renaming delay proportional to IW. D W Tag R Exc CC Old Dst. RG:E0243:L1-ILP Processors 38
EE382A Lecture 7: Dynamic Scheduling. Department of Electrical Engineering Stanford University
EE382A Lecture 7: Dynamic Scheduling Department of Electrical Engineering Stanford University http://eeclass.stanford.edu/ee382a Lecture 7-1 Announcements Project proposal due on Wed 10/14 2-3 pages submitted
More informationLimitations of Scalar Pipelines
Limitations of Scalar Pipelines Superscalar Organization Modern Processor Design: Fundamentals of Superscalar Processors Scalar upper bound on throughput IPC = 1 Inefficient unified pipeline
More informationChapter 3 (CONT II) Instructor: Josep Torrellas CS433. Copyright J. Torrellas 1999,2001,2002,2007,
Chapter 3 (CONT II) Instructor: Josep Torrellas CS433 Copyright J. Torrellas 1999,2001,2002,2007, 2013 1 Hardware-Based Speculation (Section 3.6) In multiple issue processors, stalls due to branches would
More informationECE/CS 552: Introduction to Superscalar Processors
ECE/CS 552: Introduction to Superscalar Processors Prof. Mikko Lipasti Lecture notes based in part on slides created by Mark Hill, David Wood, Guri Sohi, John Shen and Jim Smith Limitations of Scalar Pipelines
More informationAdvanced issues in pipelining
Advanced issues in pipelining 1 Outline Handling exceptions Supporting multi-cycle operations Pipeline evolution Examples of real pipelines 2 Handling exceptions 3 Exceptions In pipelined execution, one
More informationILP concepts (2.1) Basic compiler techniques (2.2) Reducing branch costs with prediction (2.3) Dynamic scheduling (2.4 and 2.5)
Instruction-Level Parallelism and its Exploitation: PART 1 ILP concepts (2.1) Basic compiler techniques (2.2) Reducing branch costs with prediction (2.3) Dynamic scheduling (2.4 and 2.5) Project and Case
More informationHandout 2 ILP: Part B
Handout 2 ILP: Part B Review from Last Time #1 Leverage Implicit Parallelism for Performance: Instruction Level Parallelism Loop unrolling by compiler to increase ILP Branch prediction to increase ILP
More informationStatic vs. Dynamic Scheduling
Static vs. Dynamic Scheduling Dynamic Scheduling Fast Requires complex hardware More power consumption May result in a slower clock Static Scheduling Done in S/W (compiler) Maybe not as fast Simpler processor
More informationChapter 3 Instruction-Level Parallelism and its Exploitation (Part 1)
Chapter 3 Instruction-Level Parallelism and its Exploitation (Part 1) ILP vs. Parallel Computers Dynamic Scheduling (Section 3.4, 3.5) Dynamic Branch Prediction (Section 3.3) Hardware Speculation and Precise
More informationSuperscalar Organization
Superscalar Organization ECE/CS 752 Fall 2017 Prof. Mikko H. Lipasti University of Wisconsin-Madison Stage Phase Function performed CPU, circa 1986 IF φ 1 Translate virtual instr. addr. using TLB φ 2 Access
More informationLecture-13 (ROB and Multi-threading) CS422-Spring
Lecture-13 (ROB and Multi-threading) CS422-Spring 2018 Biswa@CSE-IITK Cycle 62 (Scoreboard) vs 57 in Tomasulo Instruction status: Read Exec Write Exec Write Instruction j k Issue Oper Comp Result Issue
More informationCPE 631 Lecture 10: Instruction Level Parallelism and Its Dynamic Exploitation
Lecture 10: Instruction Level Parallelism and Its Dynamic Exploitation Aleksandar Milenković, milenka@ece.uah.edu Electrical and Computer Engineering University of Alabama in Huntsville Outline Tomasulo
More informationProcessor: Superscalars Dynamic Scheduling
Processor: Superscalars Dynamic Scheduling Z. Jerry Shi Assistant Professor of Computer Science and Engineering University of Connecticut * Slides adapted from Blumrich&Gschwind/ELE475 03, Peh/ELE475 (Princeton),
More informationComputer Architecture 计算机体系结构. Lecture 4. Instruction-Level Parallelism II 第四讲 指令级并行 II. Chao Li, PhD. 李超博士
Computer Architecture 计算机体系结构 Lecture 4. Instruction-Level Parallelism II 第四讲 指令级并行 II Chao Li, PhD. 李超博士 SJTU-SE346, Spring 2018 Review Hazards (data/name/control) RAW, WAR, WAW hazards Different types
More informationCSE 820 Graduate Computer Architecture. week 6 Instruction Level Parallelism. Review from Last Time #1
CSE 820 Graduate Computer Architecture week 6 Instruction Level Parallelism Based on slides by David Patterson Review from Last Time #1 Leverage Implicit Parallelism for Performance: Instruction Level
More informationChapter 4 The Processor 1. Chapter 4D. The Processor
Chapter 4 The Processor 1 Chapter 4D The Processor Chapter 4 The Processor 2 Instruction-Level Parallelism (ILP) Pipelining: executing multiple instructions in parallel To increase ILP Deeper pipeline
More informationECE 552: Introduction To Computer Architecture 1. Scalar upper bound on throughput. Instructor: Mikko H Lipasti. University of Wisconsin-Madison
ECE/CS 552: Introduction to Superscalar Processors Instructor: Mikko H Lipasti Fall 2010 University of Wisconsin-Madison Lecture notes partially based on notes by John P. Shen Limitations of Scalar Pipelines
More information5008: Computer Architecture
5008: Computer Architecture Chapter 2 Instruction-Level Parallelism and Its Exploitation CA Lecture05 - ILP (cwliu@twins.ee.nctu.edu.tw) 05-1 Review from Last Lecture Instruction Level Parallelism Leverage
More informationInstruction Level Parallelism
Instruction Level Parallelism Dynamic scheduling Scoreboard Technique Tomasulo Algorithm Speculation Reorder Buffer Superscalar Processors 1 Definition of ILP ILP=Potential overlap of execution among unrelated
More informationNOW Handout Page 1. Review from Last Time #1. CSE 820 Graduate Computer Architecture. Lec 8 Instruction Level Parallelism. Outline
CSE 820 Graduate Computer Architecture Lec 8 Instruction Level Parallelism Based on slides by David Patterson Review Last Time #1 Leverage Implicit Parallelism for Performance: Instruction Level Parallelism
More informationMetodologie di Progettazione Hardware-Software
Metodologie di Progettazione Hardware-Software Advanced Pipelining and Instruction-Level Paralelism Metodologie di Progettazione Hardware/Software LS Ing. Informatica 1 ILP Instruction-level Parallelism
More informationEEC 581 Computer Architecture. Instruction Level Parallelism (3.6 Hardware-based Speculation and 3.7 Static Scheduling/VLIW)
1 EEC 581 Computer Architecture Instruction Level Parallelism (3.6 Hardware-based Speculation and 3.7 Static Scheduling/VLIW) Chansu Yu Electrical and Computer Engineering Cleveland State University Overview
More informationCopyright 2012, Elsevier Inc. All rights reserved.
Computer Architecture A Quantitative Approach, Fifth Edition Chapter 3 Instruction-Level Parallelism and Its Exploitation 1 Branch Prediction Basic 2-bit predictor: For each branch: Predict taken or not
More informationReorder Buffer Implementation (Pentium Pro) Reorder Buffer Implementation (Pentium Pro)
Reorder Buffer Implementation (Pentium Pro) Hardware data structures retirement register file (RRF) (~ IBM 360/91 physical registers) physical register file that is the same size as the architectural registers
More informationHardware-based speculation (2.6) Multiple-issue plus static scheduling = VLIW (2.7) Multiple-issue, dynamic scheduling, and speculation (2.
Instruction-Level Parallelism and its Exploitation: PART 2 Hardware-based speculation (2.6) Multiple-issue plus static scheduling = VLIW (2.7) Multiple-issue, dynamic scheduling, and speculation (2.8)
More informationEE382A Lecture 3: Superscalar and Out-of-order Processor Basics
EE382A Lecture 3: Superscalar and Out-of-order Processor Basics Department of Electrical Engineering Stanford University http://eeclass.stanford.edu/ee382a Lecture 3-1 Announcements HW1 is due today Hand
More informationAdvanced d Instruction Level Parallelism. Computer Systems Laboratory Sungkyunkwan University
Advanced d Instruction ti Level Parallelism Jin-Soo Kim (jinsookim@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu ILP Instruction-Level Parallelism (ILP) Pipelining:
More informationEN164: Design of Computing Systems Topic 06.b: Superscalar Processor Design
EN164: Design of Computing Systems Topic 06.b: Superscalar Processor Design Professor Sherief Reda http://scale.engin.brown.edu Electrical Sciences and Computer Engineering School of Engineering Brown
More informationDynamic Scheduling. CSE471 Susan Eggers 1
Dynamic Scheduling Why go out of style? expensive hardware for the time (actually, still is, relatively) register files grew so less register pressure early RISCs had lower CPIs Why come back? higher chip
More informationCS 252 Graduate Computer Architecture. Lecture 4: Instruction-Level Parallelism
CS 252 Graduate Computer Architecture Lecture 4: Instruction-Level Parallelism Krste Asanovic Electrical Engineering and Computer Sciences University of California, Berkeley http://wwweecsberkeleyedu/~krste
More informationCPE 631 Lecture 11: Instruction Level Parallelism and Its Dynamic Exploitation
Lecture 11: Instruction Level Parallelism and Its Dynamic Exploitation Aleksandar Milenkovic, milenka@ece.uah.edu Electrical and Computer Engineering University of Alabama in Huntsville Outline Instruction
More informationChapter 3: Instruction Level Parallelism (ILP) and its exploitation. Types of dependences
Chapter 3: Instruction Level Parallelism (ILP) and its exploitation Pipeline CPI = Ideal pipeline CPI + stalls due to hazards invisible to programmer (unlike process level parallelism) ILP: overlap execution
More informationLoad1 no Load2 no Add1 Y Sub Reg[F2] Reg[F6] Add2 Y Add Reg[F2] Add1 Add3 no Mult1 Y Mul Reg[F2] Reg[F4] Mult2 Y Div Reg[F6] Mult1
Instruction Issue Execute Write result L.D F6, 34(R2) L.D F2, 45(R3) MUL.D F0, F2, F4 SUB.D F8, F2, F6 DIV.D F10, F0, F6 ADD.D F6, F8, F2 Name Busy Op Vj Vk Qj Qk A Load1 no Load2 no Add1 Y Sub Reg[F2]
More informationHardware-Based Speculation
Hardware-Based Speculation Execute instructions along predicted execution paths but only commit the results if prediction was correct Instruction commit: allowing an instruction to update the register
More informationInstruction-Level Parallelism and Its Exploitation
Chapter 2 Instruction-Level Parallelism and Its Exploitation 1 Overview Instruction level parallelism Dynamic Scheduling Techniques es Scoreboarding Tomasulo s s Algorithm Reducing Branch Cost with Dynamic
More informationCPI < 1? How? What if dynamic branch prediction is wrong? Multiple issue processors: Speculative Tomasulo Processor
1 CPI < 1? How? From Single-Issue to: AKS Scalar Processors Multiple issue processors: VLIW (Very Long Instruction Word) Superscalar processors No ISA Support Needed ISA Support Needed 2 What if dynamic
More informationCase Study IBM PowerPC 620
Case Study IBM PowerPC 620 year shipped: 1995 allowing out-of-order execution (dynamic scheduling) and in-order commit (hardware speculation). using a reorder buffer to track when instruction can commit,
More informationCS 152, Spring 2012 Section 8
CS 152, Spring 2012 Section 8 Christopher Celio University of California, Berkeley Agenda More Out- of- Order Intel Core 2 Duo (Penryn) Vs. NVidia GTX 280 Intel Core 2 Duo (Penryn) dual- core 2007+ 45nm
More informationCS 152 Computer Architecture and Engineering. Lecture 10 - Complex Pipelines, Out-of-Order Issue, Register Renaming
CS 152 Computer Architecture and Engineering Lecture 10 - Complex Pipelines, Out-of-Order Issue, Register Renaming John Wawrzynek Electrical Engineering and Computer Sciences University of California at
More informationEEC 581 Computer Architecture. Lec 7 Instruction Level Parallelism (2.6 Hardware-based Speculation and 2.7 Static Scheduling/VLIW)
EEC 581 Computer Architecture Lec 7 Instruction Level Parallelism (2.6 Hardware-based Speculation and 2.7 Static Scheduling/VLIW) Chansu Yu Electrical and Computer Engineering Cleveland State University
More informationProcessor (IV) - advanced ILP. Hwansoo Han
Processor (IV) - advanced ILP Hwansoo Han Instruction-Level Parallelism (ILP) Pipelining: executing multiple instructions in parallel To increase ILP Deeper pipeline Less work per stage shorter clock cycle
More informationEECC551 - Shaaban. 1 GHz? to???? GHz CPI > (?)
Evolution of Processor Performance So far we examined static & dynamic techniques to improve the performance of single-issue (scalar) pipelined CPU designs including: static & dynamic scheduling, static
More informationEECC551 Exam Review 4 questions out of 6 questions
EECC551 Exam Review 4 questions out of 6 questions (Must answer first 2 questions and 2 from remaining 4) Instruction Dependencies and graphs In-order Floating Point/Multicycle Pipelining (quiz 2) Improving
More informationPage 1. Recall from Pipelining Review. Lecture 16: Instruction Level Parallelism and Dynamic Execution #1: Ideas to Reduce Stalls
CS252 Graduate Computer Architecture Recall from Pipelining Review Lecture 16: Instruction Level Parallelism and Dynamic Execution #1: March 16, 2001 Prof. David A. Patterson Computer Science 252 Spring
More informationComputer Architecture A Quantitative Approach, Fifth Edition. Chapter 3. Instruction-Level Parallelism and Its Exploitation
Computer Architecture A Quantitative Approach, Fifth Edition Chapter 3 Instruction-Level Parallelism and Its Exploitation Introduction Pipelining become universal technique in 1985 Overlaps execution of
More informationCS 152, Spring 2011 Section 8
CS 152, Spring 2011 Section 8 Christopher Celio University of California, Berkeley Agenda Grades Upcoming Quiz 3 What it covers OOO processors VLIW Branch Prediction Intel Core 2 Duo (Penryn) Vs. NVidia
More informationCPI IPC. 1 - One At Best 1 - One At best. Multiple issue processors: VLIW (Very Long Instruction Word) Speculative Tomasulo Processor
Single-Issue Processor (AKA Scalar Processor) CPI IPC 1 - One At Best 1 - One At best 1 From Single-Issue to: AKS Scalar Processors CPI < 1? How? Multiple issue processors: VLIW (Very Long Instruction
More informationLecture 19: Instruction Level Parallelism
Lecture 19: Instruction Level Parallelism Administrative: Homework #5 due Homework #6 handed out today Last Time: DRAM organization and implementation Today Static and Dynamic ILP Instruction windows Register
More informationReduction of Data Hazards Stalls with Dynamic Scheduling So far we have dealt with data hazards in instruction pipelines by:
Reduction of Data Hazards Stalls with Dynamic Scheduling So far we have dealt with data hazards in instruction pipelines by: Result forwarding (register bypassing) to reduce or eliminate stalls needed
More informationDonn Morrison Department of Computer Science. TDT4255 ILP and speculation
TDT4255 Lecture 9: ILP and speculation Donn Morrison Department of Computer Science 2 Outline Textbook: Computer Architecture: A Quantitative Approach, 4th ed Section 2.6: Speculation Section 2.7: Multiple
More informationComplex Pipelining: Out-of-order Execution & Register Renaming. Multiple Function Units
6823, L14--1 Complex Pipelining: Out-of-order Execution & Register Renaming Laboratory for Computer Science MIT http://wwwcsglcsmitedu/6823 Multiple Function Units 6823, L14--2 ALU Mem IF ID Issue WB Fadd
More informationComputer Systems Architecture I. CSE 560M Lecture 10 Prof. Patrick Crowley
Computer Systems Architecture I CSE 560M Lecture 10 Prof. Patrick Crowley Plan for Today Questions Dynamic Execution III discussion Multiple Issue Static multiple issue (+ examples) Dynamic multiple issue
More informationCPE 631 Lecture 10: Instruction Level Parallelism and Its Dynamic Exploitation
Lecture 10: Instruction Level Parallelism and Its Dynamic Exploitation Aleksandar Milenkovic, milenka@ece.uah.edu Electrical and Computer Engineering University of Alabama in Huntsville Outline Instruction
More informationCS425 Computer Systems Architecture
CS425 Computer Systems Architecture Fall 2017 Multiple Issue: Superscalar and VLIW CS425 - Vassilis Papaefstathiou 1 Example: Dynamic Scheduling in PowerPC 604 and Pentium Pro In-order Issue, Out-of-order
More informationEN164: Design of Computing Systems Lecture 24: Processor / ILP 5
EN164: Design of Computing Systems Lecture 24: Processor / ILP 5 Professor Sherief Reda http://scale.engin.brown.edu Electrical Sciences and Computer Engineering School of Engineering Brown University
More informationCS 423 Computer Architecture Spring Lecture 04: A Superscalar Pipeline
CS 423 Computer Architecture Spring 2012 Lecture 04: A Superscalar Pipeline Ozcan Ozturk http://www.cs.bilkent.edu.tr/~ozturk/cs423/ [Adapted from Computer Organization and Design, Patterson & Hennessy,
More informationCISC 662 Graduate Computer Architecture Lecture 11 - Hardware Speculation Branch Predictions
CISC 662 Graduate Computer Architecture Lecture 11 - Hardware Speculation Branch Predictions Michela Taufer http://www.cis.udel.edu/~taufer/teaching/cis6627 Powerpoint Lecture Notes from John Hennessy
More informationAdapted from David Patterson s slides on graduate computer architecture
Mei Yang Adapted from David Patterson s slides on graduate computer architecture Introduction Basic Compiler Techniques for Exposing ILP Advanced Branch Prediction Dynamic Scheduling Hardware-Based Speculation
More informationUG4 Honours project selection: Talk to Vijay or Boris if interested in computer architecture projects
Announcements UG4 Honours project selection: Talk to Vijay or Boris if interested in computer architecture projects Inf3 Computer Architecture - 2017-2018 1 Last time: Tomasulo s Algorithm Inf3 Computer
More informationScoreboard information (3 tables) Four stages of scoreboard control
Scoreboard information (3 tables) Instruction : issued, read operands and started execution (dispatched), completed execution or wrote result, Functional unit (assuming non-pipelined units) busy/not busy
More informationDYNAMIC AND SPECULATIVE INSTRUCTION SCHEDULING
DYNAMIC AND SPECULATIVE INSTRUCTION SCHEDULING Slides by: Pedro Tomás Additional reading: Computer Architecture: A Quantitative Approach, 5th edition, Chapter 3, John L. Hennessy and David A. Patterson,
More informationCS252 Graduate Computer Architecture Lecture 6. Recall: Software Pipelining Example
CS252 Graduate Computer Architecture Lecture 6 Tomasulo, Implicit Register Renaming, Loop-Level Parallelism Extraction Explicit Register Renaming John Kubiatowicz Electrical Engineering and Computer Sciences
More informationCS152 Computer Architecture and Engineering March 13, 2008 Out of Order Execution and Branch Prediction Assigned March 13 Problem Set #4 Due March 25
CS152 Computer Architecture and Engineering March 13, 2008 Out of Order Execution and Branch Prediction Assigned March 13 Problem Set #4 Due March 25 http://inst.eecs.berkeley.edu/~cs152/sp08 The problem
More informationThe Processor: Instruction-Level Parallelism
The Processor: Instruction-Level Parallelism Computer Organization Architectures for Embedded Computing Tuesday 21 October 14 Many slides adapted from: Computer Organization and Design, Patterson & Hennessy
More informationAdvanced Computer Architecture
Advanced Computer Architecture 1 L E C T U R E 4: D A T A S T R E A M S I N S T R U C T I O N E X E C U T I O N I N S T R U C T I O N C O M P L E T I O N & R E T I R E M E N T D A T A F L O W & R E G I
More informationRecall from Pipelining Review. Lecture 16: Instruction Level Parallelism and Dynamic Execution #1: Ideas to Reduce Stalls
CS252 Graduate Computer Architecture Recall from Pipelining Review Lecture 16: Instruction Level Parallelism and Dynamic Execution #1: March 16, 2001 Prof. David A. Patterson Computer Science 252 Spring
More informationEITF20: Computer Architecture Part3.2.1: Pipeline - 3
EITF20: Computer Architecture Part3.2.1: Pipeline - 3 Liang Liu liang.liu@eit.lth.se 1 Outline Reiteration Dynamic scheduling - Tomasulo Superscalar, VLIW Speculation ILP limitations What we have done
More informationECE 552 / CPS 550 Advanced Computer Architecture I. Lecture 9 Instruction-Level Parallelism Part 2
ECE 552 / CPS 550 Advanced Computer Architecture I Lecture 9 Instruction-Level Parallelism Part 2 Benjamin Lee Electrical and Computer Engineering Duke University www.duke.edu/~bcl15 www.duke.edu/~bcl15/class/class_ece252fall12.html
More informationCS 152 Computer Architecture and Engineering. Lecture 12 - Advanced Out-of-Order Superscalars
CS 152 Computer Architecture and Engineering Lecture 12 - Advanced Out-of-Order Superscalars Dr. George Michelogiannakis EECS, University of California at Berkeley CRD, Lawrence Berkeley National Laboratory
More informationMulti-cycle Instructions in the Pipeline (Floating Point)
Lecture 6 Multi-cycle Instructions in the Pipeline (Floating Point) Introduction to instruction level parallelism Recap: Support of multi-cycle instructions in a pipeline (App A.5) Recap: Superpipelining
More informationCOSC4201 Instruction Level Parallelism Dynamic Scheduling
COSC4201 Instruction Level Parallelism Dynamic Scheduling Prof. Mokhtar Aboelaze Parts of these slides are taken from Notes by Prof. David Patterson (UCB) Outline Data dependence and hazards Exposing parallelism
More informationLecture 18: Instruction Level Parallelism -- Dynamic Superscalar, Advanced Techniques,
Lecture 18: Instruction Level Parallelism -- Dynamic Superscalar, Advanced Techniques, ARM Cortex-A53, and Intel Core i7 CSCE 513 Computer Architecture Department of Computer Science and Engineering Yonghong
More informationCISC 662 Graduate Computer Architecture Lecture 13 - CPI < 1
CISC 662 Graduate Computer Architecture Lecture 13 - CPI < 1 Michela Taufer http://www.cis.udel.edu/~taufer/teaching/cis662f07 Powerpoint Lecture Notes from John Hennessy and David Patterson s: Computer
More informationLecture 8 Dynamic Branch Prediction, Superscalar and VLIW. Computer Architectures S
Lecture 8 Dynamic Branch Prediction, Superscalar and VLIW Computer Architectures 521480S Dynamic Branch Prediction Performance = ƒ(accuracy, cost of misprediction) Branch History Table (BHT) is simplest
More informationPage 1. Recall from Pipelining Review. Lecture 15: Instruction Level Parallelism and Dynamic Execution
CS252 Graduate Computer Architecture Recall from Pipelining Review Lecture 15: Instruction Level Parallelism and Dynamic Execution March 11, 2002 Prof. David E. Culler Computer Science 252 Spring 2002
More informationSuperscalar Organization
Superscalar Organization Nima Honarmand Instruction-Level Parallelism (ILP) Recall: Parallelism is the number of independent tasks available ILP is a measure of inter-dependencies between insns. Average
More informationMultiple Instruction Issue and Hardware Based Speculation
Multiple Instruction Issue and Hardware Based Speculation Soner Önder Michigan Technological University, Houghton MI www.cs.mtu.edu/~soner Hardware Based Speculation Exploiting more ILP requires that we
More informationPipelining to Superscalar
Pipelining to Superscalar ECE/CS 752 Fall 207 Prof. Mikko H. Lipasti University of Wisconsin-Madison Pipelining to Superscalar Forecast Limits of pipelining The case for superscalar Instruction-level parallel
More informationLecture 9: More ILP. Today: limits of ILP, case studies, boosting ILP (Sections )
Lecture 9: More ILP Today: limits of ILP, case studies, boosting ILP (Sections 3.8-3.14) 1 ILP Limits The perfect processor: Infinite registers (no WAW or WAR hazards) Perfect branch direction and target
More informationCS152 Computer Architecture and Engineering. Complex Pipelines
CS152 Computer Architecture and Engineering Complex Pipelines Assigned March 6 Problem Set #3 Due March 20 http://inst.eecs.berkeley.edu/~cs152/sp12 The problem sets are intended to help you learn the
More informationGetting CPI under 1: Outline
CMSC 411 Computer Systems Architecture Lecture 12 Instruction Level Parallelism 5 (Improving CPI) Getting CPI under 1: Outline More ILP VLIW branch target buffer return address predictor superscalar more
More informationInstruction Level Parallelism
Instruction Level Parallelism Software View of Computer Architecture COMP2 Godfrey van der Linden 200-0-0 Introduction Definition of Instruction Level Parallelism(ILP) Pipelining Hazards & Solutions Dynamic
More informationFour Steps of Speculative Tomasulo cycle 0
HW support for More ILP Hardware Speculative Execution Speculation: allow an instruction to issue that is dependent on branch, without any consequences (including exceptions) if branch is predicted incorrectly
More informationInstruction Level Parallelism
Instruction Level Parallelism The potential overlap among instruction execution is called Instruction Level Parallelism (ILP) since instructions can be executed in parallel. There are mainly two approaches
More informationESE 545 Computer Architecture Instruction-Level Parallelism (ILP): Speculation, Reorder Buffer, Exceptions, Superscalar Processors, VLIW
Computer Architecture ESE 545 Computer Architecture Instruction-Level Parallelism (ILP): Speculation, Reorder Buffer, Exceptions, Superscalar Processors, VLIW 1 Review from Last Lecture Leverage Implicit
More informationComplex Pipelining COE 501. Computer Architecture Prof. Muhamed Mudawar
Complex Pipelining COE 501 Computer Architecture Prof. Muhamed Mudawar Computer Engineering Department King Fahd University of Petroleum and Minerals Presentation Outline Diversified Pipeline Detecting
More informationECE/CS 552: Pipelining to Superscalar Prof. Mikko Lipasti
ECE/CS 552: Pipelining to Superscalar Prof. Mikko Lipasti Lecture notes based in part on slides created by Mark Hill, David Wood, Guri Sohi, John Shen and Jim Smith Pipelining to Superscalar Forecast Real
More informationSuperscalar Processor
Superscalar Processor Design Superscalar Architecture Virendra Singh Indian Institute of Science Bangalore virendra@computer.orgorg Lecture 20 SE-273: Processor Design Superscalar Pipelines IF ID RD ALU
More informationTutorial 11. Final Exam Review
Tutorial 11 Final Exam Review Introduction Instruction Set Architecture: contract between programmer and designers (e.g.: IA-32, IA-64, X86-64) Computer organization: describe the functional units, cache
More informationHardware-based Speculation
Hardware-based Speculation M. Sonza Reorda Politecnico di Torino Dipartimento di Automatica e Informatica 1 Introduction Hardware-based speculation is a technique for reducing the effects of control dependences
More informationAnnouncements. ECE4750/CS4420 Computer Architecture L11: Speculative Execution I. Edward Suh Computer Systems Laboratory
ECE4750/CS4420 Computer Architecture L11: Speculative Execution I Edward Suh Computer Systems Laboratory suh@csl.cornell.edu Announcements Lab3 due today 2 1 Overview Branch penalties limit performance
More informationWebsite for Students VTU NOTES QUESTION PAPERS NEWS RESULTS
Advanced Computer Architecture- 06CS81 Hardware Based Speculation Tomasulu algorithm and Reorder Buffer Tomasulu idea: 1. Have reservation stations where register renaming is possible 2. Results are directly
More informationCS252 Graduate Computer Architecture Lecture 8. Review: Scoreboard (CDC 6600) Explicit Renaming Precise Interrupts February 13 th, 2010
CS252 Graduate Computer Architecture Lecture 8 Explicit Renaming Precise Interrupts February 13 th, 2010 John Kubiatowicz Electrical Engineering and Computer Sciences University of California, Berkeley
More informationAdvanced Computer Architecture. Chapter 4: More sophisticated CPU architectures
Advanced Computer Architecture Chapter 4: More sophisticated CPU architectures Lecturer: Paul H J Kelly Autumn 2001 Department of Computing Imperial College Room 423 email: phjk@doc.ic.ac.uk Course web
More informationCS252 Spring 2017 Graduate Computer Architecture. Lecture 8: Advanced Out-of-Order Superscalar Designs Part II
CS252 Spring 2017 Graduate Computer Architecture Lecture 8: Advanced Out-of-Order Superscalar Designs Part II Lisa Wu, Krste Asanovic http://inst.eecs.berkeley.edu/~cs252/sp17 WU UCB CS252 SP17 Last Time
More informationCISC 662 Graduate Computer Architecture. Lecture 10 - ILP 3
CISC 662 Graduate Computer Architecture Lecture 10 - ILP 3 Michela Taufer http://www.cis.udel.edu/~taufer/teaching/cis662f07 Powerpoint Lecture Notes from John Hennessy and David Patterson s: Computer
More informationComputer Architecture Lecture 12: Out-of-Order Execution (Dynamic Instruction Scheduling)
18-447 Computer Architecture Lecture 12: Out-of-Order Execution (Dynamic Instruction Scheduling) Prof. Onur Mutlu Carnegie Mellon University Spring 2015, 2/13/2015 Agenda for Today & Next Few Lectures
More informationCS 152 Computer Architecture and Engineering. Lecture 13 - Out-of-Order Issue and Register Renaming
CS 152 Computer Architecture and Engineering Lecture 13 - Out-of-Order Issue and Register Renaming Krste Asanovic Electrical Engineering and Computer Sciences University of California at Berkeley http://wwweecsberkeleyedu/~krste
More informationSuperscalar Processors
Superscalar Processors Superscalar Processor Multiple Independent Instruction Pipelines; each with multiple stages Instruction-Level Parallelism determine dependencies between nearby instructions o input
More information