Spring 2 Spring Loop Optimizations
|
|
|
- Sabina Bradford
- 5 years ago
- Views:
Transcription
1 Spring 2010 Loop Optimizations Instruction Scheduling
2 5 Outline Scheduling for loops Loop unrolling Software pipelining Interaction with register allocation Hardware vs. Compiler Induction Variable Recognition i loop invariant code motion Saman Amarasinghe MIT Fall 1998
3 Scheduling Loops Loop bodies are small But, lot of time is spend in loops due to large number of iterations Need better ways to schedule loops Saman Amarasinghe MIT Fall 1998
4 Machine One load/store unit load 2 cycles store 2 cycles Two arithmetic units add 2 cycles branch 2 cycles multiply 3 cycles Source Code for i = 1 to N A[i] = A[i] * b Loop Example Both units are pipelined (initiate one op each cycle) Saman Amarasinghe MIT Fall 1998
5 Loop Example Source Code for i = 1 to N A[i] = A[i] * b Assembly Code loop: mov (%rdi,%rax), %r10 imul %r11, %r10 mov %r10, (%rdi,%rax) sub $4, %rax jz loop base offset Saman Amarasinghe MIT Fall 1998
6 mov Assembly Code Loop Example mov d=7 loop: mov (%rdi,%rax), %r10 imul %r11, %r10 mov %r10, (%rdi,%rax) sub $4, %rax jz loop Schedule (9 cycles per iteration) mov imul imul imul mov sub mov sub bge bge 2 imul mov sub jz d=5 d=2 d=2 d=0 Saman Amarasinghe MIT Fall 1998
7 5 Outline Scheduling for loops Loop unrolling Software pipelining Interaction with register allocation Hardware vs. Compiler Induction Variable Recognition i loop invariant code motion Saman Amarasinghe MIT Fall 1998
8 Loop Unrolling Unroll the loop bod y few times Pros: Create a much larger basic block for the body Eliminate few loop bounds checks Cons: Much larger program Setup code (# of iterations i < unrollf factor) beginning and end of the schedule can still have unused slots Saman Amarasinghe MIT Fall 1998
9 Loop Example loop: mov (%rdi,%rax), %r10 imul %r11, %r10 mov %r10, (%rdi,%rax) sub $4, %rax jz loop Saman Amarasinghe MIT Fall 1998
10 Loop Example loop: mov (%rdi,%rax), %r10 imul %r11, %r10 mov %r10, (%rdi,%rax) sub $4, %rax mov (%rdi,%rax), %r10 imul %r11, %r10 mov %r10, (%rdi,%rax) sub $4, %rax jz loop Saman Amarasinghe MIT Fall 1998
11 Loop Example loop: mov (%rdi,%rax), %r10 imul %r11, %r10 mov %r10, (%rdi,%rax) sub $4, %rax mov (%rdi,%rax), %r10 imul %r11, %r10 mov %r10, (%rdi,%rax) sub $4, %rax jz loop Schedule (8 cycles per iteration) mov d=14 mul mov d=12 d=9 sub d=9 mov d=7 mov mov mov mov mov mov mov mov imul imul bge imul imul bge imul imul sub sub sub sub Saman Amarasinghe MIT Fall mul mov sub jz d=5 d=2 d=2 d=0
12 Loop Unrolling Rename registers Use different registers in different iterations Saman Amarasinghe MIT Fall 1998
13 Loop Example mov d=14 mul loop: 3 mov (%rdi,%rax), %r10 mov d=9 0 imul %r11, %r10 sub d=9 mov %r10, (%rdi,%rax) % 2 mov sub $4, %rax d=7 2 mov (%rdi,%rax), %r10 mul d=5 imul %r11, %r10 3 mov d=2 mov %r10, (%rdi,%rax) 0 sub $4, %rax sub d=2 jz loop 2 2 jz d=12 d=0 Saman Amarasinghe MIT Fall 1998
14 Loop Example mov d=14 mul loop: 3 mov (%rdi,%rax), %r10 mov d=9 0 imul %r11, %r10 sub d=9 mov %r10, (%rdi,%rax) % 2 mov sub $4, %rax d=7 2 mov (%rdi,%rax), %rcx mul d=5 imul %r11, %rcx 3 mov d=2 mov %rcx, (%rdi,%rax) 0 sub $4, %rax sub d=2 jz loop 2 2 jz d=12 d=0 Saman Amarasinghe MIT Fall 1998
15 Loop Unrolling Rename registers Use different registers in different iterations Eliminate unnecessary dependencies again, use more registers to eliminate true, anti and output dependencies eliminate dependent-chains of calculations when possible Saman Amarasinghe MIT Fall 1998
16 Loop Example mov 2 d=14 d=12 3 loop: mov d=9 mov (%rdi,%rax), %r10 0 imul %r11, %r10 sub d=9 2 mov %r10, (%rdi,%rax) % mov d=7 sub $4, %rax 2 mul mov (%rdi,%rax), %rcx d=5 3 imul %r11, %rcx mov d=2 mov %rcx, (%rdi,%rax) 0 sub d=2 sub $4, %rax 2 jz loop jz mul d=0 Saman Amarasinghe MIT Fall 1998
17 Loop Example mov 2 3 loop: mov d=0 mov (%rdi,%rax), %r10 0 imul %r11, %r10 sub d=0 2 mov %r10, (%rdi,%rax) % mov d=7 sub $8, %rax 2 mul mov (%rdi,%rbx), %rcx d=5 3 imul %r11, %rcx mov d=2 mov %rcx, (%rdi,%rbx) 0 sub d=2 sub $8, %rbx 2 jz loop jz mul d=5 d=3 d=0 Saman Amarasinghe MIT Fall 1998
18 2 mov d=5 Loop Example loop: mov (%rdi,%rax), %r10 imul %r11, %r10 mov %r10, (%rdi,%rax) sub $8, %rax mov (%rdi,%rbx), %rcx imul %r11, %rcx mov %rcx, (%rdi,%rbx) sub $8, %rbx jz loop Schedule (4.5 cycles per iterationti mul mov sub mov mul mov sub jz d=3 d=0 d=0 d=7 d=5 d=2 d=2 d=0 mov mov mov mov mov mov mov mov imul imul jz imul imul jz imul imul sub sub sub sub Saman Amarasinghe MIT Fall 1998
19 5 Outline Scheduling for loops Loop unrolling Software pipelining Interaction with register allocation Hardware vs. Compiler loop invariant code motion Induction Variable Recognition Saman Amarasinghe MIT Fall 1998
20 Software Pipelining Try to overla p multi ple iterations so that the slots will be filled Find the steady-state state window so that: all the instructions of the loop body is executed but from different iterations Saman Amarasinghe MIT Fall 1998
21 Loop Example mov Assembly Code loop: mov (%rdi,%rax), %r10 imul %r11, %r10 mov %r10, (%rdi,%rax) sub $4, %rax jz loop Schedule mov mul mul mul mov sub mov sub jz jz Saman Amarasinghe MIT Fall 1998
22 Assembly Code Loop Example loop: mov (%rdi,%rax), %r10 imul %r11, %r10 mov %r10, (%rdi,%rax) sub $4, %rax jz loop Schedule mov mov1 mov2 mov mov3 mov1 mov4 mov2 mov5 mov3 mov6 mov mov1 mov2 mov mov3 mov1 mov4 mov2 ld5 mov3 mul mul1 mul2 jz mul3 jz1 mul4 jz2 mul5 mul mul1 mul2 jz mul3 jz1 mul4 jz2 mul mul1 mul2 mul3 mul4 sub sub1 sub2 sub3 sub sub1 sub2 sub3 Saman Amarasinghe MIT Fall 1998
23 Loop Example Assembly Code loop: mov (%rdi,%rax), %r10 imul %r11, %r10 mov %r10, (%rdi,%rax) sub $4, %rax jz loop Schedule (2 cycles per iteration) mov mov1 mov2 mov mov3 mov1 mov4 mov2 mov5 mov3 mov6 mov mov1 mov2 mov mov3 mov1 mov4 mov2 ld5 mov3 mul mul1 mul2 jz mul3 jz1 mul4 jz2 mul5 mul mul1 mul2 jz mul3 jz1 mul4 jz2 mul mul1 mul2 mul3 mul4 sub sub1 sub2 sub3 sub sub1 sub2 sub3 Saman Amarasinghe MIT Fall 1998
24 4 iterations are overlapped value of %r11 don t change Loop Example 4 regs for (%rdi,%rax) each addr. incremented by 4*4 4 regs to keep value %r10 mov4 mov1 mul3 jz mul2 sub1 mov2 mov4 jz1 mul3 sub2 Same registers can be reused after 4 of these blocks generate code for 4 blocks, otherwise need to move loop: mov (%rdi,%rax), %r10 imul %r11, %r10 mov %r10, (%rdi,%rax) sub $4, %rax jz loop Saman Amarasinghe MIT Fall 1998
25 Code generation issues Software Pipelining Optimal use of resources Need a lot of registers Values in multiple iterations need to be kept Issues in dependencies Executing a store instruction in an iteration before branch instruction is executed for a previous iteration (writing when it should not have) Loads and stores are issued out-of-order (need to figure-out dependencies before doing this) Generate pre-amble and post-amble code Multiple blocks so no register copy is needed Saman Amarasinghe MIT Fall 1998
26 5 Outline Scheduling for loops Loop unrolling Software pipelining Interaction with register allocation Hardware vs. Compiler Induction Variable Recognition i loop invariant code motion Saman Amarasinghe MIT Fall 1998
27 Register Allocation and di Instruction ti Scheduling If register allocation is before instruction scheduling restricts the choices for scheduling Saman Amarasinghe MIT Fall 1998
28 Example 1: mov 4(%rbp), %rax 2: add %rax, %rbx 3: mov 8(%rbp), %rax 4: add %rax, %rcx Saman Amarasinghe MIT Fall 1998
29 Example 1: mov 4(%rbp), %rax 1 2: add %rax, %rbx 3 3: mov 8(%rbp), %rax 4: add %rax, %rcx Saman Amarasinghe MIT Fall 1998
30 Example 1: mov 4(%rbp), %rax 1 2: add %rax, %rbx 3 3: mov 8(%rbp), %rax 4: add %rax, %rcx ALUop MEM 1 MEM Saman Amarasinghe MIT Fall 1998
31 Example 1: mov 4(%rbp), %rax 1 2: add %rax, %rbx 3 3: mov 8(%rbp), %rax 4: add %rax, %rcx Anti-dependence How about a different register? Saman Amarasinghe MIT Fall 1998
32 Example 1: mov 4(%rbp), %rax 1 2: add %rax, %rbx 3 3: mov 8(%rbp), %r10 4: add %r10, %rcx 2 Anti-dependence How about a different register? Saman Amarasinghe MIT Fall 1998
33 Example 1: mov 4(%rbp), %rax 1 2: add %rax, %rbx 3 3: mov 8(%rbp), %r10 4: add %r10, %rcx 2 ALUop MEM 1 MEM Saman Amarasinghe MIT Fall 1998
34 Register Allocation and di Instruction ti Scheduling If register allocation is before instruction scheduling restricts the choices for scheduling Saman Amarasinghe MIT Fall 1998
35 Register Allocation andi Instructiti on Scheduli ling If register allocation is before instruction scheduling restricts the choices for scheduling If instruction scheduling before register allocation Register allocation may spill registers Will change the carefully done schedule!!! Saman Amarasinghe MIT Fall 1998
36 5 Outline Scheduling for loops Loop unrolling Software pipelining Interaction with register allocation Hardware vs. Compiler Induction Variable Recognition i loop invariant code motion Saman Amarasinghe MIT Fall 1998
37 Superscalar: Where have all the Out of order execution transistors t gone? If an instruction stalls, go beyond that and start executing non-dependent instructions Pros: Hardware scheduling Tolerates unpredictable latencies Cons: Instruction window is small Saman Amarasinghe MIT Fall 1998
38 Superscalar: Where have all the Register renaming transistors t gone? If there is an anti or output dependency of a register that stalls the pipeline, use a different hardware register Pros: Avoids anti and output dependencies Cons: Cannot do more complex transformations to eliminate dependencies Saman Amarasinghe MIT Fall 1998
39 Hardware vs. Compiler In a superscalar, hardware and compiler scheduling can work hand-in-hand Hardware can reduce the burden when not predictable by the compiler Compiler can still greatly enhance the performance Large instruction window for scheduling Many program transformations that increase parallelism Compiler is even more critical when no hardware support VLIW machines (Itanium, DSPs) Saman Amarasinghe MIT Fall 1998
40 5 Outline Scheduling for loops Loop unrolling Software pipelining Interaction with register allocation Hardware vs. Compiler Induction Variable Recognition loop invariant code motion Saman Amarasinghe MIT Fall 1998
41 Induction Variables Example i = 200 for j = 1 to 100 a(i) = 0 i = i - 1 Saman Amarasinghe MIT Fall 1998
42 Induction Variables Example i = 200 for j = 1 to 100 a(i) = 0 i = i - 1 Basic Induction variable: J =1 1, 2, 3, 4,.. Index Variable i in a(i): I = 200, 199, 198, 197. Saman Amarasinghe MIT Fall 1998
43 Induction Variables Example i = 200 for j = 1 to 100 a(i) = 0 i = i - 1 Basic Induction variable: J =1 1, 2, 3, 4,.. Index Variable i in a(i): I = 200, 199, 198, 197. = J Saman Amarasinghe MIT Fall 1998
44 Induction Variables Example i = 200 for j = 1 to 100 a(201 - j) = 0 i = i - 1 Basic Induction variable: J =1 1, 2, 3, 4,.. Index Variable i in a(i): I = 200, 199, 198, 197. = J Saman Amarasinghe MIT Fall 1998
45 Induction Variables Example for j = 1 to 100 a(201 - j) = 0 Basic Induction variable: J =1 1, 2, 3, 4,.. Index Variable i in a(i): I = 200, 199, 198, 197. = J Saman Amarasinghe MIT Fall 1998
46 What are induction variables? x is an induction variable of a loop L if variable changes its value every iteration of the loop the value is a function of number of iterations of the loop In compilers this function is normally a linear function Example: for loop index variable j, function c*j + d Saman Amarasinghe MIT Fall 1998
47 What can we do with induction variables? ibl Use them to perform strength reduction Get rid of them Saman Amarasinghe MIT Fall 1998
48 Classification of induction variables Basic induction variables Explicitly modified by the same constant amount once during each iteration of the loop Example: loop index variable Dependent induction variables Can be expressed in the form: a*x + b where a and be are loop invariant and x is an induction variable Example: 202-2*j Saman Amarasinghe MIT Fall 1998
49 Classification of induction variables Class of induction variables: All induction variables with same basic variable in their linear equations Basis of a class: the basic variable that determines that class Saman Amarasinghe MIT Fall 1998
50 Finding Basic Induction Variables Look inside loop nodes Find variables whose only modification is of the form j = j + d where d is a loop constant Saman Amarasinghe MIT Fall 1998
51 Finding Dependent Induction Variables Find all the basic induction variables Search variable k with a single assignment in the loop Variable assignments of the form k = e op j or k = -j where j is an induction variable and e is loop invariant Saman Amarasinghe MIT Fall 1998
52 Finding Dependent Induction Variables Example for i = 1 to 100 j = i*c k = j+1 Saman Amarasinghe MIT Fall 1998
53 A special case t = 202 for j = 1 to 100 t = t - 2 a(j) = t t = t - 2 b(j) = t Saman Amarasinghe MIT Fall 1998
54 A special case u1 = 200 t = 202 u2 = 202 for j = 1 to 100 for j = 1 to 100 t = t - 2 u1 = u1-4 a(j) = t a(j) = u1 t = t - 2 u2 = u2-4 b(j) = t b(j) = u2 Saman Amarasinghe MIT Fall 1998
55 5 Outline Scheduling for loops Loop unrolling Software pipelining Interaction with register allocation Hardware vs. Compiler Induction Variable Recognition i Loop invariant code motion Saman Amarasinghe MIT Fall 1998
56 Loop Invariant Code Motion If a computation produces the same value in every loop iteration, move it out of the loop Saman Amarasinghe MIT Fall 1998
57 Loop Invariant Code Motion If a computation produces the same value in every loop iteration, move it out of the loop for i = 1 to N x = x + 1 for j = 1 to N a(i,j) = 100*N + 10*i + j + x Saman Amarasinghe MIT Fall 1998
58 Loop Invariant Code Motion If a computation produces the same value in every loop iteration, move it out of the loop for i = 1 to N x = x + 1 for j = 1 to N a(i,j) = 100*N + 10*i + j + x Saman Amarasinghe MIT Fall 1998
59 Loop Invariant Code Motion If a computation produces the same value in every loop iteration, move it out of the loop t1 = 100*N for i = 1 to N x = x + 1 for j = 1 to N a(i,j) = 100*N + 10*i + j + x Saman Amarasinghe MIT Fall 1998
60 Loop Invariant Code Motion If a computation produces the same value in every loop iteration, move it out of the loop t1 = 100*N for i = 1 to N x = x + 1 for j = 1 to N a(i,j) = t1 + 10*i + j + x Saman Amarasinghe MIT Fall 1998
61 Loop Invariant Code Motion If a computation produces the same value in every loop iteration, move it out of the loop t1 = 100*N for i = 1 to N x = x + 1 for j = 1 to N a(i,j) = t1 + 10*i + j + x Saman Amarasinghe MIT Fall 1998
62 Loop Invariant Code Motion If a computation produces the same value in every loop iteration, move it out of the loop t1 = 100*N for i = 1 to N x = x + 1 for j = 1 to N a(i,j) = t1 + 10*i + j + x Saman Amarasinghe MIT Fall 1998
63 Loop Invariant Code Motion If a computation produces the same value in every loop iteration, move it out of the loop t1 = 100*N for i = 1 to N x = x + 1 t2 = t1 + 10*i + x for j = 1 to N a(i,j) = t1 + 10*i + j + x Saman Amarasinghe MIT Fall 1998
64 Loop Invariant Code Motion If a computation produces the same value in every loop iteration, move it out of the loop t1 = 100*N for i = 1 to N x = x + 1 t2 = t1 + 10*i + x for j = 1 to N a(i,j) = t2 + j Saman Amarasinghe MIT Fall 1998
65 MIT OpenCourseWare Computer Language Engineering Spring 2010 For information about citing these materials or our Terms of Use, visit:
Simple Machine Model. Lectures 14 & 15: Instruction Scheduling. Simple Execution Model. Simple Execution Model
Simple Machine Model Fall 005 Lectures & 5: Instruction Scheduling Instructions are executed in sequence Fetch, decode, execute, store results One instruction at a time For branch instructions, start fetching
What Compilers Can and Cannot Do. Saman Amarasinghe Fall 2009
What Compilers Can and Cannot Do Saman Amarasinghe Fall 009 Optimization Continuum Many examples across the compilation pipeline Static Dynamic Program Compiler Linker Loader Runtime System Optimization
More Loop Optimizations
Spring 2010 More Loop Optimizations 5 Outline Strength Reduction Loop Test Replacement Loop Invariant Code Motion SIMDization with SSE Saman Amarasinghe 2 6.035 MIT Fall 1998 Strength Reduction Replace
Administration CS 412/413. Instruction ordering issues. Simplified architecture model. Examples. Impact of instruction ordering
dministration CS 1/13 Introduction to Compilers and Translators ndrew Myers Cornell University P due in 1 week Optional reading: Muchnick 17 Lecture 30: Instruction scheduling 1 pril 00 1 Impact of instruction
Lecture 21. Software Pipelining & Prefetching. I. Software Pipelining II. Software Prefetching (of Arrays) III. Prefetching via Software Pipelining
Lecture 21 Software Pipelining & Prefetching I. Software Pipelining II. Software Prefetching (of Arrays) III. Prefetching via Software Pipelining [ALSU 10.5, 11.11.4] Phillip B. Gibbons 15-745: Software
Parallelization. Saman Amarasinghe. Computer Science and Artificial Intelligence Laboratory Massachusetts Institute of Technology
Spring 2 Parallelization Saman Amarasinghe Computer Science and Artificial Intelligence Laboratory Massachusetts Institute of Technology Outline Why Parallelism Parallel Execution Parallelizing Compilers
Unoptimized Code Generation
Unoptimized Code Generation Last time we left off on the procedure abstraction Saman Amarasinghe 2 6.035 MIT Fall 1998 The Stack Arguments 0 to 6 are in: %b %rbp %rsp %rdi, %rsi, %rdx, %rcx, %r8 and %r9
CS 152, Spring 2011 Section 10
CS 152, Spring 2011 Section 10 Christopher Celio University of California, Berkeley Agenda Stuff (Quiz 4 Prep) http://3dimensionaljigsaw.wordpress.com/2008/06/18/physics-based-games-the-new-genre/ Intel
Advanced Computer Architecture
ECE 563 Advanced Computer Architecture Fall 2010 Lecture 6: VLIW 563 L06.1 Fall 2010 Little s Law Number of Instructions in the pipeline (parallelism) = Throughput * Latency or N T L Throughput per Cycle
Code Generation. CS 540 George Mason University
Code Generation CS 540 George Mason University Compiler Architecture Intermediate Language Intermediate Language Source language Scanner (lexical analysis) tokens Parser (syntax analysis) Syntactic structure
Computer Science 246 Computer Architecture
Computer Architecture Spring 2009 Harvard University Instructor: Prof. dbrooks@eecs.harvard.edu Compiler ILP Static ILP Overview Have discussed methods to extract ILP from hardware Why can t some of these
HY425 Lecture 09: Software to exploit ILP
HY425 Lecture 09: Software to exploit ILP Dimitrios S. Nikolopoulos University of Crete and FORTH-ICS November 4, 2010 ILP techniques Hardware Dimitrios S. Nikolopoulos HY425 Lecture 09: Software to exploit
HY425 Lecture 09: Software to exploit ILP
HY425 Lecture 09: Software to exploit ILP Dimitrios S. Nikolopoulos University of Crete and FORTH-ICS November 4, 2010 Dimitrios S. Nikolopoulos HY425 Lecture 09: Software to exploit ILP 1 / 44 ILP techniques
Hardware-based Speculation
Hardware-based Speculation Hardware-based Speculation To exploit instruction-level parallelism, maintaining control dependences becomes an increasing burden. For a processor executing multiple instructions
COMPUTER ORGANIZATION AND DESIGN. The Hardware/Software Interface. Chapter 4. The Processor: C Multiple Issue Based on P&H
COMPUTER ORGANIZATION AND DESIGN The Hardware/Software Interface Chapter 4 The Processor: C Multiple Issue Based on P&H Instruction-Level Parallelism (ILP) Pipelining: executing multiple instructions in
Instruction scheduling
Instruction scheduling iaokang Qiu Purdue University ECE 468 October 12, 2018 What is instruction scheduling? Code generation has created a sequence of assembly instructions But that is not the only valid
Last time: forwarding/stalls. CS 6354: Branch Prediction (con t) / Multiple Issue. Why bimodal: loops. Last time: scheduling to avoid stalls
CS 6354: Branch Prediction (con t) / Multiple Issue 14 September 2016 Last time: scheduling to avoid stalls 1 Last time: forwarding/stalls add $a0, $a2, $a3 ; zero or more instructions sub $t0, $a0, $a1
UNIT 8 1. Explain in detail the hardware support for preserving exception behavior during Speculation.
UNIT 8 1. Explain in detail the hardware support for preserving exception behavior during Speculation. July 14) (June 2013) (June 2015)(Jan 2016)(June 2016) H/W Support : Conditional Execution Also known
Compiler Architecture
Code Generation 1 Compiler Architecture Source language Scanner (lexical analysis) Tokens Parser (syntax analysis) Syntactic structure Semantic Analysis (IC generator) Intermediate Language Code Optimizer
Multiple Instruction Issue. Superscalars
Multiple Instruction Issue Multiple instructions issued each cycle better performance increase instruction throughput decrease in CPI (below 1) greater hardware complexity, potentially longer wire lengths
EE 4683/5683: COMPUTER ARCHITECTURE
EE 4683/5683: COMPUTER ARCHITECTURE Lecture 4A: Instruction Level Parallelism - Static Scheduling Avinash Kodi, kodi@ohio.edu Agenda 2 Dependences RAW, WAR, WAW Static Scheduling Loop-carried Dependence
ECE 252 / CPS 220 Advanced Computer Architecture I. Lecture 14 Very Long Instruction Word Machines
ECE 252 / CPS 220 Advanced Computer Architecture I Lecture 14 Very Long Instruction Word Machines Benjamin Lee Electrical and Computer Engineering Duke University www.duke.edu/~bcl15 www.duke.edu/~bcl15/class/class_ece252fall11.html
CS152 Computer Architecture and Engineering VLIW, Vector, and Multithreaded Machines
CS152 Computer Architecture and Engineering VLIW, Vector, and Multithreaded Machines Assigned April 7 Problem Set #5 Due April 21 http://inst.eecs.berkeley.edu/~cs152/sp09 The problem sets are intended
Pipelining and Exploiting Instruction-Level Parallelism (ILP)
Pipelining and Exploiting Instruction-Level Parallelism (ILP) Pipelining and Instruction-Level Parallelism (ILP). Definition of basic instruction block Increasing Instruction-Level Parallelism (ILP) &
Processor (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
Floating Point/Multicycle Pipelining in DLX
Floating Point/Multicycle Pipelining in DLX Completion of DLX EX stage floating point arithmetic operations in one or two cycles is impractical since it requires: A much longer CPU clock cycle, and/or
Computer Science 146. Computer Architecture
Computer rchitecture Spring 2004 Harvard University Instructor: Prof. dbrooks@eecs.harvard.edu Lecture 11: Software Pipelining and Global Scheduling Lecture Outline Review of Loop Unrolling Software Pipelining
COMPUTER ORGANIZATION AND DESIGN The Hardware/Software Interface. 5 th. Edition. Chapter 4. The Processor
COMPUTER ORGANIZATION AND DESIGN The Hardware/Software Interface 5 th Edition Chapter 4 The Processor Introduction CPU performance factors Instruction count Determined by ISA and compiler CPI and Cycle
Final Jeopardy. CS356 Unit 15. Binary Brainteaser 100. Binary Brainteaser 200. Review
15.1 Final Jeopardy 15.2 Binary Brainteasers Instruction Inquiry Random Riddles Memory Madness Processor Predicaments Programming Pickles CS356 Unit 15 Review 100 100 100 100 100 100 200 200 200 200 200
ECE 552 / CPS 550 Advanced Computer Architecture I. Lecture 15 Very Long Instruction Word Machines
ECE 552 / CPS 550 Advanced Computer Architecture I Lecture 15 Very Long Instruction Word Machines Benjamin Lee Electrical and Computer Engineering Duke University www.duke.edu/~bcl15 www.duke.edu/~bcl15/class/class_ece252fall11.html
Course on Advanced Computer Architectures
Surname (Cognome) Name (Nome) POLIMI ID Number Signature (Firma) SOLUTION Politecnico di Milano, July 9, 2018 Course on Advanced Computer Architectures Prof. D. Sciuto, Prof. C. Silvano EX1 EX2 EX3 Q1
VLIW/EPIC: Statically Scheduled ILP
6.823, L21-1 VLIW/EPIC: Statically Scheduled ILP Computer Science & Artificial Intelligence Laboratory Massachusetts Institute of Technology Based on the material prepared by Krste Asanovic and Arvind
ECE 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
CS152 Computer Architecture and Engineering CS252 Graduate Computer Architecture. VLIW, Vector, and Multithreaded Machines
CS152 Computer Architecture and Engineering CS252 Graduate Computer Architecture VLIW, Vector, and Multithreaded Machines Assigned 3/24/2019 Problem Set #4 Due 4/5/2019 http://inst.eecs.berkeley.edu/~cs152/sp19
CS 33. Architecture and Optimization (2) CS33 Intro to Computer Systems XVI 1 Copyright 2017 Thomas W. Doeppner. All rights reserved.
CS 33 Architecture and Optimization (2) CS33 Intro to Computer Systems XVI 1 Copyright 2017 Thomas W. Doeppner. All rights reserved. Modern CPU Design Instruction Control Retirement Unit Register File
CS152 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
6.035 Project 3: Unoptimized Code Generation. Jason Ansel MIT - CSAIL
6.035 Project 3: Unoptimized Code Generation Jason Ansel MIT - CSAIL Quiz Monday 50 minute quiz Monday Covers everything up to yesterdays lecture Lexical Analysis (REs, DFAs, NFAs) Syntax Analysis (CFGs,
CS 3330 Exam 3 Fall 2017 Computing ID:
S 3330 Fall 2017 Exam 3 Variant E page 1 of 16 Email I: S 3330 Exam 3 Fall 2017 Name: omputing I: Letters go in the boxes unless otherwise specified (e.g., for 8 write not 8 ). Write Letters clearly: if
EECC551 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
Lecture: Static ILP. Topics: compiler scheduling, loop unrolling, software pipelining (Sections C.5, 3.2)
Lecture: Static ILP Topics: compiler scheduling, loop unrolling, software pipelining (Sections C.5, 3.2) 1 Static vs Dynamic Scheduling Arguments against dynamic scheduling: requires complex structures
Computer Architecture and Engineering. CS152 Quiz #5. April 23rd, Professor Krste Asanovic. Name: Answer Key
Computer Architecture and Engineering CS152 Quiz #5 April 23rd, 2009 Professor Krste Asanovic Name: Answer Key Notes: This is a closed book, closed notes exam. 80 Minutes 8 Pages Not all questions are
CS 701. Class Meets. Instructor. Teaching Assistant. Key Dates. Charles N. Fischer. Fall Tuesdays & Thursdays, 11:00 12: Engineering Hall
CS 701 Charles N. Fischer Class Meets Tuesdays & Thursdays, 11:00 12:15 2321 Engineering Hall Fall 2003 Instructor http://www.cs.wisc.edu/~fischer/cs703.html Charles N. Fischer 5397 Computer Sciences Telephone:
Simone Campanoni Loop transformations
Simone Campanoni simonec@eecs.northwestern.edu Loop transformations Outline Simple loop transformations Loop invariants Induction variables Complex loop transformations Simple loop transformations Simple
Instruction-Level Parallelism (ILP)
Instruction Level Parallelism Instruction-Level Parallelism (ILP): overlap the execution of instructions to improve performance 2 approaches to exploit ILP: 1. Rely on hardware to help discover and exploit
5008: 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
Register Allocation, i. Overview & spilling
Register Allocation, i Overview & spilling 1 L1 p ::=(label f...) f ::=(label nat nat i...) i ::=(w
Control flow graphs and loop optimizations. Thursday, October 24, 13
Control flow graphs and loop optimizations Agenda Building control flow graphs Low level loop optimizations Code motion Strength reduction Unrolling High level loop optimizations Loop fusion Loop interchange
UG4 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
INSTRUCTION LEVEL PARALLELISM
INSTRUCTION LEVEL PARALLELISM Slides by: Pedro Tomás Additional reading: Computer Architecture: A Quantitative Approach, 5th edition, Chapter 2 and Appendix H, John L. Hennessy and David A. Patterson,
Several Common Compiler Strategies. Instruction scheduling Loop unrolling Static Branch Prediction Software Pipelining
Several Common Compiler Strategies Instruction scheduling Loop unrolling Static Branch Prediction Software Pipelining Basic Instruction Scheduling Reschedule the order of the instructions to reduce the
RISC I from Berkeley. 44k Transistors 1Mhz 77mm^2
The Case for RISC RISC I from Berkeley 44k Transistors 1Mhz 77mm^2 2 MIPS: A Classic RISC ISA Instructions 4 bytes (32 bits) 4-byte aligned Instructions operate on memory and registers Memory Data types
Lecture 10: Static ILP Basics. Topics: loop unrolling, static branch prediction, VLIW (Sections )
Lecture 10: Static ILP Basics Topics: loop unrolling, static branch prediction, VLIW (Sections 4.1 4.4) 1 Static vs Dynamic Scheduling Arguments against dynamic scheduling: requires complex structures
TECH. CH14 Instruction Level Parallelism and Superscalar Processors. What is Superscalar? Why Superscalar? General Superscalar Organization
CH14 Instruction Level Parallelism and Superscalar Processors Decode and issue more and one instruction at a time Executing more than one instruction at a time More than one Execution Unit What is Superscalar?
Tutorial 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
Advanced Instruction-Level Parallelism
Advanced Instruction-Level Parallelism Jinkyu Jeong (jinkyu@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu EEE3050: Theory on Computer Architectures, Spring 2017, Jinkyu
HW 2 is out! Due 9/25!
HW 2 is out! Due 9/25! CS 6290 Static Exploitation of ILP Data-Dependence Stalls w/o OOO Single-Issue Pipeline When no bypassing exists Load-to-use Long-latency instructions Multiple-Issue (Superscalar),
CPE300: Digital System Architecture and Design
CPE300: Digital System Architecture and Design Fall 2011 MW 17:30-18:45 CBC C316 Pipelining 11142011 http://www.egr.unlv.edu/~b1morris/cpe300/ 2 Outline Review I/O Chapter 5 Overview Pipelining Pipelining
Lecture 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
CS433 Homework 3 (Chapter 3)
CS433 Homework 3 (Chapter 3) Assigned on 10/3/2017 Due in class on 10/17/2017 Instructions: 1. Please write your name and NetID clearly on the first page. 2. Refer to the course fact sheet for policies
Computer 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
CMSC411 Fall 2013 Midterm 2 Solutions
CMSC411 Fall 2013 Midterm 2 Solutions 1. (12 pts) Memory hierarchy a. (6 pts) Suppose we have a virtual memory of size 64 GB, or 2 36 bytes, where pages are 16 KB (2 14 bytes) each, and the machine has
CS425 Computer Systems Architecture
CS425 Computer Systems Architecture Fall 2018 Static Instruction Scheduling 1 Techniques to reduce stalls CPI = Ideal CPI + Structural stalls per instruction + RAW stalls per instruction + WAR stalls per
EN164: Design of Computing Systems Topic 08: Parallel Processor Design (introduction)
EN164: Design of Computing Systems Topic 08: Parallel Processor Design (introduction) Professor Sherief Reda http://scale.engin.brown.edu Electrical Sciences and Computer Engineering School of Engineering
Chapter 3 (Cont III): Exploiting ILP with Software Approaches. Copyright Josep Torrellas 1999, 2001, 2002,
Chapter 3 (Cont III): Exploiting ILP with Software Approaches Copyright Josep Torrellas 1999, 2001, 2002, 2013 1 Exposing ILP (3.2) Want to find sequences of unrelated instructions that can be overlapped
CS 2410 Mid term (fall 2015) Indicate which of the following statements is true and which is false.
CS 2410 Mid term (fall 2015) Name: Question 1 (10 points) Indicate which of the following statements is true and which is false. (1) SMT architectures reduces the thread context switch time by saving in
Computer Architecture and Engineering CS152 Quiz #4 April 11th, 2012 Professor Krste Asanović
Computer Architecture and Engineering CS152 Quiz #4 April 11th, 2012 Professor Krste Asanović Name: ANSWER SOLUTIONS This is a closed book, closed notes exam. 80 Minutes 17 Pages Notes: Not all questions
15.1. CS356 Unit 15. Review
15.1 CS356 Unit 15 Review 15.2 Final Jeopardy Binary Brainteasers Instruction Inquiry Random Riddles Memory Madness Processor Predicaments Programming Pickles 100 100 100 100 100 100 200 200 200 200 200
CS 33. Architecture and Optimization (2) CS33 Intro to Computer Systems XV 1 Copyright 2016 Thomas W. Doeppner. All rights reserved.
CS 33 Architecture and Optimization (2) CS33 Intro to Computer Systems XV 1 Copyright 2016 Thomas W. Doeppner. All rights reserved. Modern CPU Design Instruc&on Control Re%rement Unit Register File Fetch
CS 152 Computer Architecture and Engineering. Lecture 16 - VLIW Machines and Statically Scheduled ILP
CS 152 Computer Architecture and Engineering Lecture 16 - VLIW Machines and Statically Scheduled ILP Krste Asanovic Electrical Engineering and Computer Sciences University of California at Berkeley http://www.eecs.berkeley.edu/~krste
Lecture: Static ILP. Topics: loop unrolling, software pipelines (Sections C.5, 3.2)
Lecture: Static ILP Topics: loop unrolling, software pipelines (Sections C.5, 3.2) 1 Loop Example for (i=1000; i>0; i--) x[i] = x[i] + s; Source code FPALU -> any: 3 s FPALU -> ST : 2 s IntALU -> BR :
CE431 Parallel Computer Architecture Spring Compile-time ILP extraction Modulo Scheduling
CE431 Parallel Computer Architecture Spring 2018 Compile-time ILP extraction Modulo Scheduling Nikos Bellas Electrical and Computer Engineering University of Thessaly Parallel Computer Architecture 1 Readings
CS 152 Computer Architecture and Engineering. Lecture 13 - VLIW Machines and Statically Scheduled ILP
CS 152 Computer Architecture and Engineering Lecture 13 - VLIW Machines and Statically Scheduled ILP Krste Asanovic Electrical Engineering and Computer Sciences University of California at Berkeley http://www.eecs.berkeley.edu/~krste!
COSC 6385 Computer Architecture - Pipelining
COSC 6385 Computer Architecture - Pipelining Fall 2006 Some of the slides are based on a lecture by David Culler, Instruction Set Architecture Relevant features for distinguishing ISA s Internal storage
CSE 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
Lecture: Pipeline Wrap-Up and Static ILP
Lecture: Pipeline Wrap-Up and Static ILP Topics: multi-cycle instructions, precise exceptions, deep pipelines, compiler scheduling, loop unrolling, software pipelining (Sections C.5, 3.2) 1 Multicycle
CS6303 Computer Architecture Regulation 2013 BE-Computer Science and Engineering III semester 2 MARKS
CS6303 Computer Architecture Regulation 2013 BE-Computer Science and Engineering III semester 2 MARKS UNIT-I OVERVIEW & INSTRUCTIONS 1. What are the eight great ideas in computer architecture? The eight
EXAM #1. CS 2410 Graduate Computer Architecture. Spring 2016, MW 11:00 AM 12:15 PM
EXAM #1 CS 2410 Graduate Computer Architecture Spring 2016, MW 11:00 AM 12:15 PM Directions: This exam is closed book. Put all materials under your desk, including cell phones, smart phones, smart watches,
Load1 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
![Load1 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](/thumbs/92/108067849.jpg "Load1 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]
Getting 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
CMSC22200 Computer Architecture Lecture 8: Out-of-Order Execution. Prof. Yanjing Li University of Chicago
CMSC22200 Computer Architecture Lecture 8: Out-of-Order Execution Prof. Yanjing Li University of Chicago Administrative Stuff! Lab2 due tomorrow " 2 free late days! Lab3 is out " Start early!! My office
HPC VT Machine-dependent Optimization
HPC VT 2013 Machine-dependent Optimization Last time Choose good data structures Reduce number of operations Use cheap operations strength reduction Avoid too many small function calls inlining Use compiler
Advanced 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:
In-order vs. Out-of-order Execution. In-order vs. Out-of-order Execution
In-order vs. Out-of-order Execution In-order instruction execution instructions are fetched, executed & committed in compilergenerated order if one instruction stalls, all instructions behind it stall
The 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
Instruction-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
Real Processors. Lecture for CPSC 5155 Edward Bosworth, Ph.D. Computer Science Department Columbus State University
Real Processors Lecture for CPSC 5155 Edward Bosworth, Ph.D. Computer Science Department Columbus State University Instruction-Level Parallelism (ILP) Pipelining: executing multiple instructions in parallel
Lecture 8: Compiling for ILP and Branch Prediction. Advanced pipelining and instruction level parallelism
Lecture 8: Compiling for ILP and Branch Prediction Kunle Olukotun Gates 302 kunle@ogun.stanford.edu http://www-leland.stanford.edu/class/ee282h/ 1 Advanced pipelining and instruction level parallelism
Instruction Scheduling. Software Pipelining - 3
Instruction Scheduling and Software Pipelining - 3 Department of Computer Science and Automation Indian Institute of Science Bangalore 560 012 NPTEL Course on Principles of Compiler Design Instruction
Chapter 4. The Processor
Chapter 4 The Processor Introduction CPU performance factors Instruction count Determined by ISA and compiler CPI and Cycle time Determined by CPU hardware We will examine two MIPS implementations A simplified
CS433 Midterm. Prof Josep Torrellas. October 16, Time: 1 hour + 15 minutes
CS433 Midterm Prof Josep Torrellas October 16, 2014 Time: 1 hour + 15 minutes Name: Alias: Instructions: 1. This is a closed-book, closed-notes examination. 2. The Exam has 4 Questions. Please budget your
last time out-of-order execution and instruction queues the data flow model idea
1 last time 2 out-of-order execution and instruction queues the data flow model idea graph of operations linked by depedencies latency bound need to finish longest dependency chain multiple accumulators
Multi-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
COSC 6385 Computer Architecture. - Memory Hierarchies (II)
COSC 6385 Computer Architecture - Memory Hierarchies (II) Fall 2008 Cache Performance Avg. memory access time = Hit time + Miss rate x Miss penalty with Hit time: time to access a data item which is available
Lecture 19. Software Pipelining. I. Example of DoAll Loops. I. Introduction. II. Problem Formulation. III. Algorithm.
Lecture 19 Software Pipelining I. Introduction II. Problem Formulation III. Algorithm I. Example of DoAll Loops Machine: Per clock: 1 read, 1 write, 1 (2-stage) arithmetic op, with hardware loop op and
4. The Processor Computer Architecture COMP SCI 2GA3 / SFWR ENG 2GA3. Emil Sekerinski, McMaster University, Fall Term 2015/16
4. The Processor Computer Architecture COMP SCI 2GA3 / SFWR ENG 2GA3 Emil Sekerinski, McMaster University, Fall Term 2015/16 Instruction Execution Consider simplified MIPS: lw/sw rt, offset(rs) add/sub/and/or/slt
16.10 Exercises. 372 Chapter 16 Code Improvement. be translated as
372 Chapter 16 Code Improvement 16.10 Exercises 16.1 In Section 16.2 we suggested replacing the instruction r1 := r2 / 2 with the instruction r1 := r2 >> 1, and noted that the replacement may not be correct
Computer 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
Exploiting ILP with SW Approaches. Aleksandar Milenković, Electrical and Computer Engineering University of Alabama in Huntsville
Lecture : Exploiting ILP with SW Approaches Aleksandar Milenković, milenka@ece.uah.edu Electrical and Computer Engineering University of Alabama in Huntsville Outline Basic Pipeline Scheduling and Loop
CS24: INTRODUCTION TO COMPUTING SYSTEMS. Spring 2018 Lecture 4
CS24: INTRODUCTION TO COMPUTING SYSTEMS Spring 2018 Lecture 4 LAST TIME Enhanced our processor design in several ways Added branching support Allows programs where work is proportional to the input values
NOW 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