advances in loop analysis frameworks and optimizations
play

Advances in Loop Analysis Frameworks and Optimizations Adam Nemet - PowerPoint PPT Presentation

Nov 15, 2022 •459 likes •1.62k views

Advances in Loop Analysis Frameworks and Optimizations Adam Nemet & Michael Zolotukhin Apple Loop Unrolling for (x = 0; x < 6; x++) { foo(x); } Loop Unrolling for (x = 0; x < 6; x += 2) { for (x = 0; x < 6; x++) { foo(x);

  1. Can We Vectorize It? Iteration K: t = dc[k-1] + tpdd[k-1]; dc[k] = t; Iteration K+1: t2 = dc[k] + tpdd[k]; dc[k+1] = t2;

  2. Can We Vectorize It? Iteration K: t = dc[k-1] + tpdd[k-1]; Iteration K+1: t2 = dc[k] + tpdd[k]; dc[k] = t; dc[k+1] = t2;

  3. Can We Vectorize It? dc[k] = = dc[k-1] + tpdd[k-1]; if ((sc = mc[k-1] + tpmd[k-1]) > dc[k]) dc[k] = sc; if (dc[k] < -INFTY) dc[k] = -INFTY;

  4. Case Study for (k = 1; k <= M; k++) { mc[k] = mpp[k-1] + tpmm[k-1]; if ((sc = ip[k-1] + tpim[k-1]) > mc[k]) mc[k] = sc; if ((sc = dpp[k-1] + tpdm[k-1]) > mc[k]) mc[k] = sc; if ((sc = xmb + bp[k]) > mc[k]) mc[k] = sc; mc[k] += ms[k]; if (mc[k] < -INFTY) mc[k] = -INFTY; dc[k] = dc[k-1] + tpdd[k-1]; Non-vectorizable if ((sc = mc[k-1] + tpmd[k-1]) > dc[k]) dc[k] = sc; if (dc[k] < -INFTY) dc[k] = -INFTY; if (k < M) { ic[k] = mpp[k] + tpmi[k]; if ((sc = ip[k] + tpii[k]) > ic[k]) ic[k] = sc; ic[k] += is[k]; if (ic[k] < -INFTY) ic[k] = -INFTY; sk} }

  5. Case Study for (k = 1; k <= M; k++) { mc[k] = mpp[k-1] + tpmm[k-1]; if ((sc = ip[k-1] + tpim[k-1]) > mc[k]) mc[k] = sc; Vectorizable if ((sc = dpp[k-1] + tpdm[k-1]) > mc[k]) mc[k] = sc; if ((sc = xmb + bp[k]) > mc[k]) mc[k] = sc; mc[k] += ms[k]; if (mc[k] < -INFTY) mc[k] = -INFTY; dc[k] = dc[k-1] + tpdd[k-1]; Non-vectorizable if ((sc = mc[k-1] + tpmd[k-1]) > dc[k]) dc[k] = sc; if (dc[k] < -INFTY) dc[k] = -INFTY; if (k < M) { ic[k] = mpp[k] + tpmi[k]; if ((sc = ip[k] + tpii[k]) > ic[k]) ic[k] = sc; ic[k] += is[k]; if (ic[k] < -INFTY) ic[k] = -INFTY; sk} }

  6. Case Study if (k < M) { ic[k] = mpp[k] + tpmi[k]; if ((sc = ip[k] + tpii[k]) > ic[k]) ic[k] = sc; ic[k] += is[k]; if (ic[k] < -INFTY) ic[k] = -INFTY; sk}

  7. Case Study if (k < M) { ic[k] = mpp[k] + tpmi[k]; if ((sc = ip[k] + tpii[k]) > ic[k]) ic[k] = sc; ic[k] += is[k]; if (ic[k] < -INFTY) ic[k] = -INFTY; sk}

  8. Case Study for (k = 1; k <= M; k++) { mc[k] = mpp[k-1] + tpmm[k-1]; if ((sc = ip[k-1] + tpim[k-1]) > mc[k]) mc[k] = sc; Vectorizable if ((sc = dpp[k-1] + tpdm[k-1]) > mc[k]) mc[k] = sc; if ((sc = xmb + bp[k]) > mc[k]) mc[k] = sc; mc[k] += ms[k]; if (mc[k] < -INFTY) mc[k] = -INFTY; dc[k] = dc[k-1] + tpdd[k-1]; if ((sc = mc[k-1] + tpmd[k-1]) > dc[k]) dc[k] = sc; if (dc[k] < -INFTY) dc[k] = -INFTY; Non-vectorizable Non-vectorizable if (k < M) { ic[k] = mpp[k] + tpmi[k]; if ((sc = ip[k] + tpii[k]) > ic[k]) ic[k] = sc; ic[k] += is[k]; if (ic[k] < -INFTY) ic[k] = -INFTY; sk} }

  9. Case Study for (k = 1; k <= M; k++) { mc[k] = mpp[k-1] + tpmm[k-1]; if ((sc = ip[k-1] + tpim[k-1]) > mc[k]) mc[k] = sc; Vectorizable if ((sc = dpp[k-1] + tpdm[k-1]) > mc[k]) mc[k] = sc; if ((sc = xmb + bp[k]) > mc[k]) mc[k] = sc; mc[k] += ms[k]; if (mc[k] < -INFTY) mc[k] = -INFTY; } for (k = 1; k <= M; k++) { dc[k] = dc[k-1] + tpdd[k-1]; if ((sc = mc[k-1] + tpmd[k-1]) > dc[k]) dc[k] = sc; if (dc[k] < -INFTY) dc[k] = -INFTY; Non-vectorizable Non-vectorizable if (k < M) { ic[k] = mpp[k] + tpmi[k]; if ((sc = ip[k] + tpii[k]) > ic[k]) ic[k] = sc; ic[k] += is[k]; if (ic[k] < -INFTY) ic[k] = -INFTY; sk} }

  10. Plan • Distribute loop • Let LoopVectorizer vectorize top loop -> Partial Loop Vectorization

  11. Loop Distribution

  12. Pros and Cons + Partial loop vectorization + Improve memory access pattern: • Cache associativity • Number of HW prefetcher streams + Reduce spilling - Loop overhead - Instructions duplicated across new loops - Instruction-level parallelism

  13. Legality for (k = 1; k <= M; k++) { mc[k] = mpp[k-1] + tpmm[k-1]; if ((sc = ip[k-1] + tpim[k-1]) > mc[k]) mc[k] = sc; if ((sc = dpp[k-1] + tpdm[k-1]) > mc[k]) mc[k] = sc; if ((sc = xmb + bp[k]) > mc[k]) mc[k] = sc; mc[k] += ms[k]; if (mc[k] < -INFTY) mc[k] = -INFTY; } for (k = 1; k <= M; k++) { dc[k] = dc[k-1] + tpdd[k-1]; if ((sc = mc[k-1] + tpmd[k-1]) > dc[k]) dc[k] = sc; if (dc[k] < -INFTY) dc[k] = -INFTY; if (k < M) { Loop Run-time ic[k] = mpp[k] + tpmi[k]; if ((sc = ip[k] + tpii[k]) > ic[k]) ic[k] = sc; Dependence Alias ic[k] += is[k]; Analysis Checks if (ic[k] < -INFTY) ic[k] = -INFTY; } }

  14. Loop Access Analysis • Born from the Loop Vectorizer • Generalized as new analysis pass • Computed on-demand and cached • New Loop Versioning utility

  15. Algorithm • Light-weight • Uses only LoopAccessAnalysis • No Program Dependence Graph • No Control Dependence • Inner loops only • Different from textbook algorithm • No reordering of memory operations

  16. Algorithm mul 1 st 2 ld 3 st 4 ld 5 add 6 st 7 ld 8 mul 9 st 10

  17. Algorithm mul 1 st 2 ld 3 st 4 ld 5 add 6 st 7 ld 8 mul 9 st 10

  18. Algorithm mul 1 st 2 ld 3 st 4 ld 5 add 6 st 7 ld 8 mul 9 st 10

  19. Algorithm mul 1 st 2 ld 3 st 4 ld 5 add 6 st 7 ld 8 mul 9 st 10

  20. Algorithm mul 1 st 2 ld 3 st 4 ld 5 add 6 st 7 ld 8 mul 9 st 10

  21. Algorithm mul 1 st 2 ld 3 st 4 ld 5 add 6 st 7 ld 8 mul 9 st 10

  22. Algorithm mul 1 st 2 ld 3 st 4 ld 5 add 6 st 7 ld 8 mul 9 st 10

  23. Algorithm mul 1 st 2 ld 3 st 4 ld 5 add 6 st 7 ld 8 mul 9 st 10

  24. Algorithm mul 1 st 2 ld 3 st 4 ld 5 add 6 st 7 ld 8 mul 9 st 10

  25. Algorithm mul 1 st 2 ld 3 st 4 ld 5 add 6 st 7 ld 8 mul 9 st 10

  26. Algorithm mul 1 st 2 ld 3 st 4 ld 5 add 6 st 7 ld 8 mul 9 st 10

  27. Algorithm mul 1 st 2 ld 3 st 4 dup of ld 5 mul 1 add 6 st 7 ld 8 mul 9 st 10

  28. Algorithm mul 1 st 2 ld 3 st 4 dup of ld 5 mul 1 add 6 st 7 ld 8 mul 9 st 10

  29. Algorithm mul 1 st 2 ld 3 st 4 dup of ld 5 mul 1 add 6 st 7 ld 8 mul 9 st 10

  30. Algorithm mul 1 st 2 ld 3 st 4 dup of ld 5 mul 1 add 6 st 7 ld 8 mul 9 st 10

  31. Algorithm mul 1 st 2 ld 3 st 4 dup of ld 5 mul 1 add 6 st 7 ld 8 mul 9 st 10

  32. Algorithm mul 1 st 2 ld 3 st 4 dup of ld 5 mul 1 add 6 st 7 dup of ld 8 ld 3 mul 9 st 10

  33. Algorithm mul 1 st 2 ld 3 st 4 dup of ld 5 mul 1 add 6 st 7 ld 8 mul 9 st 10

  34. Algorithm mul 1 st 2 ld 3 st 4 dup of ld 5 mul 1 add 6 st 7 ld 8 mul 9 st 10

  35. Algorithm mul 1 st 2 ld 3 st 4 dup of ld 5 mul 1 add 6 st 7 ld 8 mul 9 st 10

  36. Recap • Distributed loop • Versioned with run-time alias checks • Top loop vectorized

  37. Case Study for (k = 1; k <= M; k++) { mc[k] = mpp[k-1] + tpmm[k-1]; if ((sc = ip[k-1] + tpim[k-1]) > mc[k]) mc[k] = sc; Vectorized if ((sc = dpp[k-1] + tpdm[k-1]) > mc[k]) mc[k] = sc; if ((sc = xmb + bp[k]) > mc[k]) mc[k] = sc; mc[k] += ms[k]; if (mc[k] < -INFTY) mc[k] = -INFTY; } for (k = 1; k <= M; k++) { dc[k] = dc[k-1] + tpdd[k-1]; if ((sc = mc[k-1] + tpmd[k-1]) > dc[k]) dc[k] = sc; if (dc[k] < -INFTY) dc[k] = -INFTY; if (k < M) { ic[k] = mpp[k] + tpmi[k]; if ((sc = ip[k] + tpii[k]) > ic[k]) ic[k] = sc; ic[k] += is[k]; if (ic[k] < -INFTY) ic[k] = -INFTY; sk} }

  38. Case Study for (k = 1; k <= M; k++) { dc[k] = dc[k-1] + tpdd[k-1]; if ((sc = mc[k-1] + tpmd[k-1]) > dc[k]) dc[k] = sc; if (dc[k] < -INFTY) dc[k] = -INFTY; if (k < M) { ic[k] = mpp[k] + tpmi[k]; if ((sc = ip[k] + tpii[k]) > ic[k]) ic[k] = sc; ic[k] += is[k]; if (ic[k] < -INFTY) ic[k] = -INFTY; sk} }

  39. Case Study dc[k] = dc[k-1] + tpdd[k-1]; if ((sc = mc[k-1] + tpmd[k-1]) > dc[k]) dc[k] = sc; if (dc[k] < -INFTY) dc[k] = -INFTY;

  40. Case Study Load Load Load Load Add Add Cmp DC[k-1] —> DC[k] Csel Cmp Csel Store

  41. Case Study Load Load Load Load Add Add HW st -> ld forwarding Cmp Csel Cmp Csel Store

  42. Case Study Load Load Load Load Add Add HW st -> ld forwarding Cmp SW st -> ld forwarding Csel Cmp Csel Store

  43. Case Study dc[k] = dc[k-1] + tpdd[k-1]; if ((sc = mc[k-1] + tpmd[k-1]) > dc[k]) dc[k] = sc; if (dc[k] < -INFTY) dc[k] = -INFTY;

  44. Loop Load Elimination

  45. Algorithm 1. Find loop-carried dependences with iteration distance of one 2. Between store -> load? 3. No (may-)intervening store 4. Propagate value stored to uses of load

  46. Algorithm for (k = 1; k <= M; k++) { dc[k] = = dc[k-1] + tpdd[k-1]; = sc; if ((sc = mc[k-1] + tpmd[k-1]) > dc[k]) dc[k] = = -INFTY; if (dc[k] < -INFTY) dc[k] = if (k < M) { ic[k] = mpp[k] + tpmi[k]; if ((sc = ip[k] + tpii[k]) > ic[k]) ic[k] = sc; ic[k] += is[k]; if (ic[k] < -INFTY) ic[k] = -INFTY; sk} }

  47. Algorithm for (k = 1; k <= M; k++) { dc[k] = = dc[k-1] + tpdd[k-1]; T if ((sc = mc[k-1] + tpmd[k-1]) > dc[k]) dc[k] = T = sc; if (dc[k] < -INFTY) dc[k] = = -INFTY; T if (k < M) { ic[k] = mpp[k] + tpmi[k]; if ((sc = ip[k] + tpii[k]) > ic[k]) ic[k] = sc; ic[k] += is[k]; if (ic[k] < -INFTY) ic[k] = -INFTY; sk} }

  48. Algorithm for (k = 1; k <= M; k++) { dc[k] = = T + tpdd[k-1]; T if ((sc = mc[k-1] + tpmd[k-1]) > dc[k]) dc[k] = T = sc; if (dc[k] < -INFTY) dc[k] = = -INFTY; T if (k < M) { ic[k] = mpp[k] + tpmi[k]; if ((sc = ip[k] + tpii[k]) > ic[k]) ic[k] = sc; ic[k] += is[k]; if (ic[k] < -INFTY) ic[k] = -INFTY; sk} }

  49. Algorithm T = dc[0]; for (k = 1; k <= M; k++) { dc[k] = = T + tpdd[k-1]; T if ((sc = mc[k-1] + tpmd[k-1]) > dc[k]) dc[k] = T = sc; if (dc[k] < -INFTY) dc[k] = = -INFTY; T if (k < M) { ic[k] = mpp[k] + tpmi[k]; if ((sc = ip[k] + tpii[k]) > ic[k]) ic[k] = sc; ic[k] += is[k]; if (ic[k] < -INFTY) ic[k] = -INFTY; sk} }

  50. Algorithm T = dc[0]; for (k = 1; k <= M; k++) { dc[k] = = T + tpdd[k-1]; T if ((sc = mc[k-1] + tpmd[k-1]) > dc[k]) dc[k] = T = sc; if (dc[k] < -INFTY) dc[k] = = -INFTY; T if (k < M) { ic[k] = mpp[k] + tpmi[k]; if ((sc = ip[k] + tpii[k]) > ic[k]) ic[k] = sc; ic[k] += is[k]; if (ic[k] < -INFTY) ic[k] = -INFTY; sk} }

  51. Loop Load Elimination • Simple and cheap using Loop Access Analysis • With Loop Versioning can optimize more loops • GVN Load-PRE can be simplified to not worry about loop cases

  52. Recap • Distributed loop into two loops • Versioned with run-time alias checks • Vectorized top loop • Store-to-load forwarding in bottom loop • Versioned with run-time alias checks

  53. Results • 20-30% gain on 456.hmmer on ARM64 and x86 • Loop Access Analysis pass • Loop Versioning utility • Loop Distribution pass • Loop Load Elimination pass

  54. Future Work • Commit Loop Load Elimination • Tune Loop Distribution and turn it on by default • Loop Distribution with Program Dependence Graph

  55. Acknowledgements • Chandler Carruth • Hal Finkel • Arnold Schwaighofer • Daniel Berlin

  56. Q&A

Recommend

Loop Optimizations Important because lots of execution Loop Optimizations Loop Optimizations

Loop Optimizations Important because lots of execution Loop Optimizations Loop Optimizations

Loop Optimizations Important because lots of execution Loop Optimizations Loop Optimizations time occurs in loops First, we will identify loops We will study three optimizations Loop-invariant code motion This lecture is

249 views • 5 slides
Principles of Program Analysis An overview of approaches beyond loop analysis and optimizations

Principles of Program Analysis An overview of approaches beyond loop analysis and optimizations

Principles of Program Analysis An overview of approaches beyond loop analysis and optimizations cs6363 1 The Nature of static analysis --- approximation Static program analysis --- predict the dynamic behavior of programs without running

368 views • 19 slides
Lecture 6.2 Loop Optimizations EN 600.320/420 Instructor: Randal Burns 14 February 2018

Lecture 6.2 Loop Optimizations EN 600.320/420 Instructor: Randal Burns 14 February 2018

Lecture 6.2 Loop Optimizations EN 600.320/420 Instructor: Randal Burns 14 February 2018 Department of Computer Science, Johns Hopkins University How to Make Loops Faster Make bigger to eliminate startup costs Loop unrolling Loop

615 views • 14 slides
Outline Unreachable-Code Elimination Straightening If and Loop Simplifications

Outline Unreachable-Code Elimination Straightening If and Loop Simplifications

Outline Unreachable-Code Elimination Straightening If and Loop Simplifications Loop Inversion and Unswitching Control-Flow and Low-Level Branch Optimizations Optimizations Tail Merging (Cross Jumping) Conditional

360 views • 8 slides
Outline Unreachable-Code Elimination P3 / 2003 Straightening If and Loop

Outline Unreachable-Code Elimination P3 / 2003 Straightening If and Loop

Outline Unreachable-Code Elimination P3 / 2003 Straightening If and Loop Simplifications Control-Flow and Low-Level Loop Inversion and Unswitching Branch Optimizations Optimizations Tail Merging (Cross Jumping)

102 views • 8 slides
Analysis and Optimizations Analysis and Optimizations Program Analysis Program Analysis

Analysis and Optimizations Analysis and Optimizations Program Analysis Program Analysis

Analysis and Optimizations Analysis and Optimizations Program Analysis Program Analysis Discovers properties of a program Optimizations Using Program Analysis Use analysis results to transform program Use analysis results

744 views • 17 slides
TDT4205 Lecture 29 2 Where we are We have a handful of different analysis instances

TDT4205 Lecture 29 2 Where we are We have a handful of different analysis instances

1 Control flow and loop detection TDT4205 Lecture 29 2 Where we are We have a handful of different analysis instances None of them are optimizations, in and of themselves The objective now is to Show how loop detection is

343 views • 15 slides
Recent Advances in Two-loop Superstrings Eric DHoker Institut des Hautes Etudes Scientifiques,

Recent Advances in Two-loop Superstrings Eric DHoker Institut des Hautes Etudes Scientifiques,

Recent Advances in Two-loop Superstrings Eric DHoker Institut des Hautes Etudes Scientifiques, 2014 May 6 Eric DHoker Recent Advances in Two-loop Superstrings Outline 1. Overview of two-loop superstring methods, including global issues;

627 views • 31 slides
Analysis and Optimizations Program Analysis P3 / 2006 Discovers properties of a program

Analysis and Optimizations Program Analysis P3 / 2006 Discovers properties of a program

Analysis and Optimizations Program Analysis P3 / 2006 Discovers properties of a program Optimizations Using Program Analysis Use analysis results to transform program for Optimization Goal: improve some aspect of program

232 views • 12 slides
How to Get Good Performance by Using OpenMP ! ! Loop optimizations ! ! Measuring OpenMP

How to Get Good Performance by Using OpenMP ! ! Loop optimizations ! ! Measuring OpenMP

Agenda ! How to Get Good Performance by Using OpenMP ! ! Loop optimizations ! ! Measuring OpenMP performance ! ! Best practices ! ! Task parallelism !! !&quot; #&quot; Memory access patterns ! Correctness versus performance ! It

168 views • 14 slides
Loop Optimizations in LLVM: The Good, The Bad, and The Ugly Michael Kruse, Hal Finkel Argonne

Loop Optimizations in LLVM: The Good, The Bad, and The Ugly Michael Kruse, Hal Finkel Argonne

Loop Optimizations in LLVM: The Good, The Bad, and The Ugly Michael Kruse, Hal Finkel Argonne Leadership Computing Facility Argonne National Laboratory 18 th October 2018 Acknowledgments This research was supported by the Exascale Computing

1.11k views • 81 slides
Outline Outline Unreachable-Code Elimination Unreachable Code Elimination Control-Flow and

Outline Outline Unreachable-Code Elimination Unreachable Code Elimination Control-Flow and

Outline Outline Unreachable-Code Elimination Unreachable Code Elimination Control-Flow and Low-Level Straightening If and Loop Simplifications If and Loop Simplifications Optimizations Optimizations Loop Inversion and

254 views • 10 slides
Loop Fusion and Fission and Presburger Trans Framework ! Last time ! Unimodular transformation

Loop Fusion and Fission and Presburger Trans Framework ! Last time ! Unimodular transformation

Loop Fusion and Fission and Presburger Trans Framework ! Last time ! Unimodular transformation framework ! Loop permutation, Loop reversal, Loop skewing ! Fourier Motzkin ! Frameworks ! Unimodular ! Polyhedral ! Presburger

483 views • 12 slides
V3 Loop Sequence Space Analysis Kasia Bo ek bozek@mpi-inf.mpg.de Max-Planck Institute fr

V3 Loop Sequence Space Analysis Kasia Bo ek bozek@mpi-inf.mpg.de Max-Planck Institute fr

V3 Loop Sequence Space Analysis Kasia Bo ek bozek@mpi-inf.mpg.de Max-Planck Institute fr Informatik, Saarbrcken AREVIR Bonn 24.04.2009 V3 loop sequence space analysis selection of V3 loop sequence variants for experimental imaging of

613 views • 15 slides
S9500 - Deep Learning Framework Container Optimizations Joey Conway, Senior Product Manager of

S9500 - Deep Learning Framework Container Optimizations Joey Conway, Senior Product Manager of

S9500 - Deep Learning Framework Container Optimizations Joey Conway, Senior Product Manager of Deep Learning Software Michael OConnor, Director of Software, Optimized Frameworks Cliff Woolley, Director of Engineering, Optimized Frameworks

311 views • 29 slides
AutoTVM &amp; Device Fleet ` Learning to Optimize Tensor Programs Frameworks High-level data

AutoTVM &amp; Device Fleet ` Learning to Optimize Tensor Programs Frameworks High-level data

AutoTVM &amp; Device Fleet ` Learning to Optimize Tensor Programs Frameworks High-level data flow graph and optimizations Hardware Learning to Optimize Tensor Programs Frameworks High-level data flow graph and optimizations Hardware

921 views • 46 slides
1 Legality of Loop Interchange (cont) Loop Interchange Example Case analysis of the direction

1 Legality of Loop Interchange (cont) Loop Interchange Example Case analysis of the direction

Loop Transformations for Parallelism &amp; Locality Loop Permutation Idea Previously Swap the order of two loops to increase parallelism, to improve spatial Data dependences and loops locality, or to enable other transformations

604 views • 5 slides
Dynamic Optimizations Last time Predication and speculation Today Dynamic compilation

Dynamic Optimizations Last time Predication and speculation Today Dynamic compilation

Dynamic Optimizations Last time Predication and speculation Today Dynamic compilation CS553 Lecture Dynamic Optimizations 2 Motivation Limitations of static analysis Programs can have values and invariants that are known at

375 views • 14 slides
Upper and Lower Loop Bound Estimation by Symbolic Execution and Loop Acceleration Pavel Cadek

Upper and Lower Loop Bound Estimation by Symbolic Execution and Loop Acceleration Pavel Cadek

Upper and Lower Loop Bound Estimation by Symbolic Execution and Loop Acceleration Pavel Cadek 1 1 TU Wien, Austria Formal Methods in Computer-Aided Design 30 Oct - 2 Nov, 2018 Loop Bound Analysis Upper loop bound: max { n , 0 } Lower loop

248 views • 5 slides
Analysis and Parallelization Optimizations of Weather Codes Jess Labarta BSC Petascale Tools

Analysis and Parallelization Optimizations of Weather Codes Jess Labarta BSC Petascale Tools

www.bsc.es Analysis and Parallelization Optimizations of Weather Codes Jess Labarta BSC Petascale Tools Workshop, Madison, August 4 th 2014 Earth and Climate A complex system Multicomponent Dynamic High impact Societal,

789 views • 36 slides
Coarse-Grained Parallelism Variable Privatization, Loop Alignment, Loop Fusion, Loop

Coarse-Grained Parallelism Variable Privatization, Loop Alignment, Loop Fusion, Loop

Coarse-Grained Parallelism Variable Privatization, Loop Alignment, Loop Fusion, Loop interchange and skewing, Loop Strip-mining cs6363 1 Introduction Our previous loop transformations target vector and superscalar architectures Now

538 views • 32 slides
Repetition Types of Loops Counting loop Know how many times to loop

Repetition Types of Loops Counting loop Know how many times to loop

Repetition Types of Loops Counting loop Know how many times to loop Sentinel-controlled loop Expect specific input value to end loop Endfile-controlled loop End of data file is end of loop Input validation loop

257 views • 8 slides
Profile-Guided Optimizations Last time Instruction scheduling Register renaming

Profile-Guided Optimizations Last time Instruction scheduling Register renaming

Profile-Guided Optimizations Last time Instruction scheduling Register renaming Balanced Load Scheduling Loop unrolling Software pipelining Today More instruction scheduling Profiling Trace scheduling CS553

250 views • 10 slides
Trading Strategies Introduction Trading Loop Trading Loop Trading Loop Trading Loop Three

Trading Strategies Introduction Trading Loop Trading Loop Trading Loop Trading Loop Three

Trading Strategies Introduction Trading Loop Trading Loop Trading Loop Trading Loop Three Strategies 1. Mean Reversion 2. Momentum 3. Pairs Trading Budish, E., Cramton, P ., &amp; Shim, J. (2015). The high-frequency trading arms race:

803 views • 22 slides

More recommend