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

Download Presentation
Download Policy: The content available on the website is offered to you 'AS IS' for your personal information and use only. It cannot be commercialized, licensed, or distributed on other websites without prior consent from the author. To download a presentation, simply click this link. If you encounter any difficulties during the download process, it's possible that the publisher has removed the file from their server.

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

166 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
Crankshaft Turbocharging the next generation of web applications Overview Why did we

Crankshaft Turbocharging the next generation of web applications Overview Why did we

Kasper Lund, Software engineer at Google Crankshaft Turbocharging the next generation of web applications Overview Why did we introduce Crankshaft? Deciding when and what to optimize Type feedback and intermediate

909 views • 32 slides
EE 457 Unit 9c Thread Level Parallelism 2 Credits Some of the material in this presentation

EE 457 Unit 9c Thread Level Parallelism 2 Credits Some of the material in this presentation

1 EE 457 Unit 9c Thread Level Parallelism 2 Credits Some of the material in this presentation is taken from: Computer Architecture: A Quantitative Approach John Hennessy &amp; David Patterson Some of the material in this

785 views • 43 slides
Network Layers Standardization Cruelty 2009/08/12 (C) Herbert Haas The good thing about

Network Layers Standardization Cruelty 2009/08/12 (C) Herbert Haas The good thing about

Network Layers Standardization Cruelty 2009/08/12 (C) Herbert Haas The good thing about standards is that there are so many to choose from Andrew S. Tanenbaum Standards We need networking standards Ensure interoperability

691 views • 40 slides
Networkcontrolandmanagement Networkmanagement

Networkcontrolandmanagement Networkmanagement

Networkcontrolandmanagement Networkmanagement Whatisnetworkmanagement?? Whyisitneeded? ManiSubramanian, NetworkManagement:An

606 views • 47 slides
Effectiveness of CMPs Prepared for: ICO Ref: jn1666/BW Date: April/2014 1 UK I

Effectiveness of CMPs Prepared for: ICO Ref: jn1666/BW Date: April/2014 1 UK I

Effectiveness of CMPs Prepared for: ICO Ref: jn1666/BW Date: April/2014 1 UK I FRANCE I ITALY Contents Background &amp; Objectives Approach/ notes about qualitative research Key findings Detailed Findings Study

1.48k views • 60 slides
In-network Monitoring and Control Policy for DVFS of CMP Networks- on-Chip and Last Level Caches

In-network Monitoring and Control Policy for DVFS of CMP Networks- on-Chip and Last Level Caches

In-network Monitoring and Control Policy for DVFS of CMP Networks- on-Chip and Last Level Caches Xi Chen 1 , Zheng Xu 1 , Hyungjun Kim 1 , Paul V. Gratz 1 , Jiang Hu 1 , Michael Kishinevsky 2 and Umit Ogras 2 1 Computer Engineering and Systems

581 views • 30 slides
Ithemal: Accurate, Portable and Fast Basic Block Throughput Estimation using Deep Neural Networks

Ithemal: Accurate, Portable and Fast Basic Block Throughput Estimation using Deep Neural Networks

Ithemal: Accurate, Portable and Fast Basic Block Throughput Estimation using Deep Neural Networks Charith Mendis Alex Renda Saman Amarasinghe Michael Carbin Compilers need to search through code Sequences High-level code Optimizing

1.08k views • 20 slides
Binary Search Trees These slides are not fully polished: - some transitions are rough - some

Binary Search Trees These slides are not fully polished: - some transitions are rough - some

Binary Search Trees These slides are not fully polished: - some transitions are rough - some topics are not covered -they probably contain mistakes Be aware of this as you use them. Reflecting on Dictionaries Cost Worst-case complexity o

816 views • 42 slides

More recommend