Calpa: A Tool for Automating Dynamic Compilation

Slides:



Advertisements
Similar presentations
Uncovering Performance Problems in Java Applications with Reference Propagation Profiling PRESTO: Program Analyses and Software Tools Research Group, Ohio.
Advertisements

School of EECS, Peking University “Advanced Compiler Techniques” (Fall 2011) Parallelism & Locality Optimization.
Mantis: Automatic Performance Prediction for Smartphone Applications Byung-Gon Chun Microsoft Yongin Kwon, Sangmin Lee, Hayoon Yi, Donghyun Kwon, Seungjun.
Dynamic Optimization using ADORE Framework 10/22/2003 Wei Hsu Computer Science and Engineering Department University of Minnesota.
ECE 454 Computer Systems Programming Compiler and Optimization (I) Ding Yuan ECE Dept., University of Toronto
Kristof Beyls, Erik D’Hollander, Frederik Vandeputte ICCS 2005 – May 23 RDVIS: A Tool That Visualizes the Causes of Low Locality and Hints Program Optimizations.
Breaking SIMD Shackles with an Exposed Flexible Microarchitecture and the Access Execute PDG Venkatraman Govindaraju, Tony Nowatzki, Karthikeyan Sankaralingam.
Department of Computer Science and Engineering University of Washington Brian N. Bershad, Stefan Savage, Przemyslaw Pardyak, Emin Gun Sirer, Marc E. Fiuczynski,
Overview Motivations Basic static and dynamic optimization methods ADAPT Dynamo.
Code Transformations to Improve Memory Parallelism Vijay S. Pai and Sarita Adve MICRO-32, 1999.
Fully Dynamic Specialization AJ Shankar OSQ Lunch 9 December 2003.
Enabling Efficient On-the-fly Microarchitecture Simulation Thierry Lafage September 2000.
Discovery of Locality-Improving Refactorings by Reuse Path Analysis – Kristof Beyls – HPCC pag. 1 Discovery of Locality-Improving Refactorings.
Fast Paths in Concurrent Programs Wen Xu, Princeton University Sanjeev Kumar, Intel Labs. Kai Li, Princeton University.
Extensibility, Safety and Performance in the SPIN Operating System Department of Computer Science and Engineering, University of Washington Brian N. Bershad,
Specialization Run-time Code Generation in the context of Dynamic Compilation presented by Mujtaba Ali.
Increasing the Cache Efficiency by Eliminating Noise Philip A. Marshall.
Eliminating Stack Overflow by Abstract Interpretation John Regehr Alastair Reid Kirk Webb University of Utah.
SCIENCES USC INFORMATION INSTITUTE An Open64-based Compiler Approach to Performance Prediction and Performance Sensitivity Analysis for Scientific Codes.
Automatically Proving the Correctness of Compiler Optimizations Sorin Lerner Todd Millstein Craig Chambers University of Washington.
Fast Effective Dynamic Compilation Joel Auslander, Mathai Philipose, Craig Chambers, etc. PLDI’96 Department of Computer Science and Engineering Univ.
Memory Systems Performance Workshop 2004© David Ryan Koes MSP 2004 Programmer Specified Pointer Independence David Koes Mihai Budiu Girish Venkataramani.
BROADWAY: A SOFTWARE ARCHITECTURE FOR SCIENTIFIC COMPUTING Samuel Z. Guyer and Calvin Lin The University of Texas.
Improving Data-flow Analysis with Path Profiles ● Glenn Ammons & James R. Larus ● University of Wisconsin-Madison ● 1998 ● Presented by Jessica Friis.
Run-Time Storage Organization
Microprocessors Introduction to ia64 Architecture Jan 31st, 2002 General Principles.
MoBIES Working group meeting, September 2001, Dearborn Ptolemy II The automotive challenge problems version 4.1 Johan Eker Edward Lee with thanks.
Runtime Optimization with Specialization Johnathon Jamison CS265 Susan Graham
Compilation, Architectural Support, and Evaluation of SIMD Graphics Pipeline Programs on a General-Purpose CPU Mauricio Breternitz Jr, Herbert Hum, Sanjeev.
University of California San Diego Locality Phase Prediction Xipeng Shen, Yutao Zhong, Chen Ding Computer Science Department, University of Rochester Class.
Composing Dataflow Analyses and Transformations Sorin Lerner (University of Washington) David Grove (IBM T.J. Watson) Craig Chambers (University of Washington)
Personalized Ontologies for Web Search and Caching Susan Gauch Information and Telecommunications Technology Center Electrical Engineering and Computer.
CISC673 – Optimizing Compilers1/34 Presented by: Sameer Kulkarni Dept of Computer & Information Sciences University of Delaware Phase Ordering.
Software Testing Verification and validation planning Software inspections Software Inspection vs. Testing Automated static analysis Cleanroom software.
Prospector : A Toolchain To Help Parallel Programming Minjang Kim, Hyesoon Kim, HPArch Lab, and Chi-Keung Luk Intel This work will be also supported by.
P ARALLEL P ROCESSING I NSTITUTE · F UDAN U NIVERSITY 1.
Adaptive Optimization in the Jalapeño JVM Matthew Arnold Stephen Fink David Grove Michael Hind Peter F. Sweeney Source: UIUC.
Scalable Analysis of Distributed Workflow Traces Daniel K. Gunter and Brian Tierney Distributed Systems Department Lawrence Berkeley National Laboratory.
1 Advance Computer Architecture CSE 8383 Ranya Alawadhi.
HW/SW PARTITIONING OF FLOATING POINT SOFTWARE APPLICATIONS TO FIXED - POINTED COPROCESSOR CIRCUITS - Nalini Kumar Gaurav Chitroda Komal Kasat.
John Mellor-Crummey Robert Fowler Nathan Tallent Gabriel Marin Department of Computer Science, Rice University Los Alamos Computer Science Institute HPCToolkit.
University of Maryland Dynamic Floating-Point Error Detection Mike Lam, Jeff Hollingsworth and Pete Stewart.
Improving I/O with Compiler-Supported Parallelism Why Should We Care About I/O? Disk access speeds are much slower than processor and memory access speeds.
Using Cache Models and Empirical Search in Automatic Tuning of Applications Apan Qasem Ken Kennedy John Mellor-Crummey Rice University Houston, TX Apan.
CSCI1600: Embedded and Real Time Software Lecture 33: Worst Case Execution Time Steven Reiss, Fall 2015.
Compilers as Collaborators and Competitors of High-Level Specification Systems David Padua University of Illinois at Urbana-Champaign.
Machine Learning in Compiler Optimization By Namita Dave.
Static and Integration Testing. Static Testing vs Dynamic Testing  To find defects  This testing includes verification process  without executing.
Architectural Effects on DSP Algorithms and Optimizations Sajal Dogra Ritesh Rathore.
Learning A Better Compiler Predicting Unroll Factors using Supervised Classification And Integrating CPU and L2 Cache Voltage Scaling using Machine Learning.
Michael J. Voss and Rudolf Eigenmann PPoPP, ‘01 (Presented by Kanad Sinha)
Profiling/Tracing Method and Tool Evaluation Strategy Summary Slides Hung-Hsun Su UPC Group, HCS lab 1/25/2005.
High-level optimization Jakub Yaghob
Compiler Construction (CS-636)
An Evaluation of Staged Run-Time Optimizations in DyC
OOP What is problem? Solution? OOP
AUTOMATED SESSION PLANNING. In the present world, everything has become automated. By, a click everything is being processed. But the preparation of the.
The Simplest Heuristics May Be The Best in Java JIT Compilers
CSCI1600: Embedded and Real Time Software
Feedback directed optimization in Compaq’s compilation tools for Alpha
Adaptive Code Unloading for Resource-Constrained JVMs
Mock Object Creation for Test Factoring
when it needs to be done at compile-time
Samuel Larsen and Saman Amarasinghe, MIT CSAIL
Dynamic Program Analysis
Samuel Larsen Saman Amarasinghe Laboratory for Computer Science
How to improve (decrease) CPI
rePLay: A Hardware Framework for Dynamic Optimization
C. M. Overstreet Old Dominion University Fall 2005
CSCI1600: Embedded and Real Time Software
Presentation transcript:

Calpa: A Tool for Automating Dynamic Compilation Markus Mock, Mark Berryman, Craig Chambers, and Susan J. Eggers University of Washington

Outline Motivation Overview of DyC Calpa System Experimental Results Conclusion Discussion

Motivation Run time constants Optimizations Specialized code regions Constant propagation Loop unrolling Specialized code regions Dynamic optimization > run-time cost

DyC: Dynamic Compiler Annotation directed run time specialization Manual annotation requires Good knowledge of application run-time behavior Run time costs? Legal annotation? X = 3 /* run time constant (but not really…) */

Motivation for Calpa Manual annotation is difficult, and often becomes bottleneck Automated annotation = Calpa

Calpa Combines program analysis and profile information to automatically derive annotations Cost / Benefit Model predicts effect of annotation Implemented with SUIF

Experimental Results Small and medium applications annotated Instrumented program size: x 8-14 Run time of instrumented executable: x 2 – 4 orders of magnitude (x = un-instrumented application)

Conclusion Calpa automates annotation process for dynamic compilation It is faster and produces better annotations than manual process

Discussion Dynamic Compiler needs more work Too slow for actual gains Run time constants can boost ILP and memory prefetching What about phase oriented optimizations?