DOCSLIB.ORG

Practical and Effective Higher-Order Optimizations

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Practical and Effective Higher-Order Optimizations PREPRINT: To be presented at ICFP ’14, September 1–6, 2014, Gothenburg, Sweden. Practical and Effective Higher-Order Optimizations Lars Bergstrom Matthew Fluet John Reppy Mozilla Research ∗ Matthew Le Nora Sandler [email protected] Rochester Institute of Technology University of Chicago fmtf,[email protected] fjhr,[email protected] Abstract Categories and Subject Descriptors D.3.0 [Programming Lan- Inlining is an optimization that replaces a call to a function with that guages]: General; D.3.2 [Programming Languages]: Language function’s body. This optimization not only reduces the overhead Classifications—Applicative (functional) languages; D.3.4 [Pro- of a function call, but can expose additional optimization oppor- gramming Languages]: Processors—Optimization tunities to the compiler, such as removing redundant operations or Keywords control-flow analysis, inlining, optimization unused conditional branches. Another optimization, copy propaga- tion, replaces a redundant copy of a still-live variable with the origi- 1. Introduction nal. Copy propagation can reduce the total number of live variables, reducing register pressure and memory usage, and possibly elimi- All high level programming languages rely on compiler optimiza- nating redundant memory-to-memory copies. In practice, both of tions to transform a language that is convenient for software devel- these optimizations are implemented in nearly every modern com- opers into one that runs efficiently on target hardware. Two such piler. common compiler optimizations are copy propagation and func- These two optimizations are practical to implement and effec- tion inlining. Copy propagation in a language like ML is a simple tive in first-order languages, but in languages with lexically-scoped substitution. Given a program of the form: first-class functions (aka, closures), these optimizations are not let val x = y available to code programmed in a higher-order style. With higher- in order functions, the analysis challenge has been that the environ- x*2+y ment at the call site must be the same as at the closure capture end location, up to the free variables, or the meaning of the program We want to propagate the definition of x to its uses, resulting in may change. Olin Shivers’ 1991 dissertation called this family of let val x = y optimizations Super-β and he proposed one analysis technique, in called reflow, to support these optimizations. Unfortunately, reflow y*2+y has proven too expensive to implement in practice. Because these end higher-order optimizations are not available in functional-language At this point, we can eliminate the now unused x, resulting in compilers, programmers studiously avoid uses of higher-order val- ues that cannot be optimized (particularly in compiler benchmarks). y*2+y This paper provides the first practical and effective technique This optimization can reduce the resource requirements (i.e., reg- for Super-β (higher-order) inlining and copy propagation, which ister pressure) of a program, and it may open the possibility for we call unchanged variable analysis. We show that this technique further simplifications in later optimization phases. is practical by implementing it in the context of a real compiler Inlining replaces a lexically inferior application of a function for an ML-family language and showing that the required analy- with the body of that function by performing straightforward β- ses have costs below 3% of the total compilation time. This tech- substitution. For example, given the program nique’s effectiveness is shown through a set of benchmarks and ex- ample programs, where this analysis exposes additional potential let fun f x = 2*x in optimization sites. f 3 end ∗ Portions of this work were performed while the author was at the Univer- inlining f and removing the unused definition results in sity of Chicago. 2*3 This optimization removes the cost of the function call and opens the possibility of further optimizations, such as constant folding. Inlining does require some care, however, since it can increase the program size, which can negatively affect the instruction cache per- formance, negating the benefits of eliminating call overhead. The importance of inlining for functional languages and techniques for providing predictable performance are well-covered in the context of GHC by Peyton Jones and Marlow [PM02]. Both copy propagation and function inlining have been well- studied and are widely implemented in modern compilers for both [Copyright notice will appear here once ’preprint’ option is removed.] first-order and higher-order programming languages. In this paper, we are interested in the higher-order version of these optimizations, While some compilers can reproduce similar results on trivial which are not used in practice because of the cost of the supporting examples such as these, implementing either of these optimizations analysis. in their full generality requires an environment-aware analysis to For example, consider the following iterative program: prove their safety. In the case of copy propagation, we need to ensure that the variable being substituted has the same value at the let fun emit x = print (Int.toString x) point that it is being substituted as it did when it was passed in. fun fact i m k = Similarly, if we want to substitute the body of a function at its call if i=0 then k m site, we need to ensure that all of the free variables have the same else fact (i-1) (m*i) k values at the call site as they did at the point where the function in fact 6 1 emit was defined. Today, developers using higher-order languages often end avoid writing programs that have non-trivial environment usage within code that is run in a loop unless they have special knowledge Higher-order copy propagation would allow the compiler to prop- of either the compiler or additional annotations on library functions agate the function emit into the body of fact, resulting in the (e.g., map) that will enable extra optimization. following program: This paper presents a new approach to control-flow analysis let (CFA) that supports more optimization opportunities for higher- fun emit x = print (Int.toString x) order programs than are possible in either type-directed optimiz- fun fact i m k = ers, heuristics-based approaches, or by using library-method anno- if i=0 then emit m tations. We use the example of transducers [SM06], a higher-order else fact (i-1) (m*i) emit in and compositional programming style, to further motivate these op- fact 6 1 emit timizations and to explain our novel analysis. end Our contributions are: This transformation has replaced an indirect call to emit (via the • A novel, practical environment analysis (Section 5) that pro- variable k) with a direct call. Direct calls are typically faster than vides a conservative approximation of when two occurrences indirect calls,1 and are amenable to function inlining. Furthermore, of a variable will have the same binding. the parameter k can be eliminated using useless variable elimina- • Timing results (Section 9) for the implementation of this analy- tion [Shi91], which results in a smaller program that uses fewer sis and related optimizations, showing that it requires less than resources: 3% of overall compilation time. let • Performance results for several benchmarks, showing that even fun emit x = print (Int.toString x) fun fact i m = highly tuned programs still contain higher-order optimization if i=0 then emit m opportunities. else fact (i-1) (m*i) in Source code for our complete implementation and fact 6 1 all the benchmarks described in this paper is available end at: http://smlnj-gforge.cs.uchicago.edu/ projects/manticore/. Function inlining also has a similar higher-order counterpart (what Shivers calls Super-β ). For example, in the following pro- gram, we can inline the body of pr at the call site inside fact, 2. Manticore despite the fact that pr is not in scope in fact: The techniques described in this paper have been developed as part let of the Manticore project and are implemented in the compiler for val two = 2 Parallel ML, which is a parallel dialect of Standard ML [FRRS11]. fun fact i m k = In this section, we give an overview of the host compiler and in- if i=0 termediate representation upon which we perform our analysis and then k m else fact (i-1) (m*i) k optimizations. The compiler is a whole-program compiler, read- fun pr x = print (Int.toString (x*two)) ing in the files in the source code alongside the sources from in the runtime library. As covered in more detail in an earlier pa- fact 6 1 pr per [FFR+07], there are six distinct intermediate representations end (IRs) in the Manticore compiler: Inlining pr produces 1. Parse tree — the product of the parser. let 2. AST — an explicitly-typed abstract-syntax tree representation. val two = 2 fun fact i m k = 3. BOM — a direct style normalized λ-calculus. if i=0 then print (Int.toString (m*two)) 4. CPS — a continuation-passing style λ-calculus. else fact (i-1) (m i) k * 5. CFG — a first-order control-flow graph representation. fun pr x = print (Int.toString (x*two)) in 6. MLTree — the expression tree representation used by the ML- fact 6 1 pr end RISC code generation framework [GGR94]. The work in this paper is performed on the CPS representation. This resulting program is now eligible for constant propagation and useless variable elimination. 2.1 CPS 1 Direct calls to known functions can use specialized calling conven- Continuation-passing style (CPS) is the final high-level represen- tions that are more efficient and provide more predictability to hardware tation used in the compiler before closure conversion generates a instruction-prefetch mechanisms.
Load more

Recommended publications
  • Polyhedral Compilation As a Design Pattern for Compiler Construction
    Polyhedral Compilation as a Design Pattern for Compiler Construction PLISS, May 19-24, 2019 [email protected] Polyhedra? Example: Tiles Polyhedra? Example: Tiles How many of you read “Design Pattern”? → Tiles Everywhere 1. Hardware Example: Google Cloud TPU Architectural Scalability With Tiling Tiles Everywhere 1. Hardware Google Edge TPU Edge computing zoo Tiles Everywhere 1. Hardware 2. Data Layout Example: XLA compiler, Tiled data layout Repeated/Hierarchical Tiling e.g., BF16 (bfloat16) on Cloud TPU (should be 8x128 then 2x1) Tiles Everywhere Tiling in Halide 1. Hardware 2. Data Layout Tiled schedule: strip-mine (a.k.a. split) 3. Control Flow permute (a.k.a. reorder) 4. Data Flow 5. Data Parallelism Vectorized schedule: strip-mine Example: Halide for image processing pipelines vectorize inner loop https://halide-lang.org Meta-programming API and domain-specific language (DSL) for loop transformations, numerical computing kernels Non-divisible bounds/extent: strip-mine shift left/up redundant computation (also forward substitute/inline operand) Tiles Everywhere TVM example: scan cell (RNN) m = tvm.var("m") n = tvm.var("n") 1. Hardware X = tvm.placeholder((m,n), name="X") s_state = tvm.placeholder((m,n)) 2. Data Layout s_init = tvm.compute((1,n), lambda _,i: X[0,i]) s_do = tvm.compute((m,n), lambda t,i: s_state[t-1,i] + X[t,i]) 3. Control Flow s_scan = tvm.scan(s_init, s_do, s_state, inputs=[X]) s = tvm.create_schedule(s_scan.op) 4. Data Flow // Schedule to run the scan cell on a CUDA device block_x = tvm.thread_axis("blockIdx.x") 5. Data Parallelism thread_x = tvm.thread_axis("threadIdx.x") xo,xi = s[s_init].split(s_init.op.axis[1], factor=num_thread) s[s_init].bind(xo, block_x) Example: Halide for image processing pipelines s[s_init].bind(xi, thread_x) xo,xi = s[s_do].split(s_do.op.axis[1], factor=num_thread) https://halide-lang.org s[s_do].bind(xo, block_x) s[s_do].bind(xi, thread_x) print(tvm.lower(s, [X, s_scan], simple_mode=True)) And also TVM for neural networks https://tvm.ai Tiling and Beyond 1.
    [Show full text]
  • Expression Rematerialization for VLIW DSP Processors with Distributed Register Files ?
    Expression Rematerialization for VLIW DSP Processors with Distributed Register Files ? Chung-Ju Wu, Chia-Han Lu, and Jenq-Kuen Lee Department of Computer Science, National Tsing-Hua University, Hsinchu 30013, Taiwan {jasonwu,chlu}@pllab.cs.nthu.edu.tw,[email protected] Abstract. Spill code is the overhead of memory load/store behavior if the available registers are not sufficient to map live ranges during the process of register allocation. Previously, works have been proposed to reduce spill code for the unified register file. For reducing power and cost in design of VLIW DSP processors, distributed register files and multi- bank register architectures are being adopted to eliminate the amount of read/write ports between functional units and registers. This presents new challenges for devising compiler optimization schemes for such ar- chitectures. This paper aims at addressing the issues of reducing spill code via rematerialization for a VLIW DSP processor with distributed register files. Rematerialization is a strategy for register allocator to de- termine if it is cheaper to recompute the value than to use memory load/store. In the paper, we propose a solution to exploit the character- istics of distributed register files where there is the chance to balance or split live ranges. By heuristically estimating register pressure for each register file, we are going to treat them as optional spilled locations rather than spilling to memory. The choice of spilled location might pre- serve an expression result and keep the value alive in different register file. It increases the possibility to do expression rematerialization which is effectively able to reduce spill code.
    [Show full text]
  • Equality Saturation: a New Approach to Optimization
    Logical Methods in Computer Science Vol. 7 (1:10) 2011, pp. 1–37 Submitted Oct. 12, 2009 www.lmcs-online.org Published Mar. 28, 2011 EQUALITY SATURATION: A NEW APPROACH TO OPTIMIZATION ROSS TATE, MICHAEL STEPP, ZACHARY TATLOCK, AND SORIN LERNER Department of Computer Science and Engineering, University of California, San Diego e-mail address: {rtate,mstepp,ztatlock,lerner}@cs.ucsd.edu Abstract. Optimizations in a traditional compiler are applied sequentially, with each optimization destructively modifying the program to produce a transformed program that is then passed to the next optimization. We present a new approach for structuring the optimization phase of a compiler. In our approach, optimizations take the form of equality analyses that add equality information to a common intermediate representation. The op- timizer works by repeatedly applying these analyses to infer equivalences between program fragments, thus saturating the intermediate representation with equalities. Once saturated, the intermediate representation encodes multiple optimized versions of the input program. At this point, a profitability heuristic picks the final optimized program from the various programs represented in the saturated representation. Our proposed way of structuring optimizers has a variety of benefits over previous approaches: our approach obviates the need to worry about optimization ordering, enables the use of a global optimization heuris- tic that selects among fully optimized programs, and can be used to perform translation validation, even on compilers other than our own. We present our approach, formalize it, and describe our choice of intermediate representation. We also present experimental results showing that our approach is practical in terms of time and space overhead, is effective at discovering intricate optimization opportunities, and is effective at performing translation validation for a realistic optimizer.
    [Show full text]
  • CS153: Compilers Lecture 19: Optimization
    CS153: Compilers Lecture 19: Optimization Stephen Chong https://www.seas.harvard.edu/courses/cs153 Contains content from lecture notes by Steve Zdancewic and Greg Morrisett Announcements •HW5: Oat v.2 out •Due in 2 weeks •HW6 will be released next week •Implementing optimizations! (and more) Stephen Chong, Harvard University 2 Today •Optimizations •Safety •Constant folding •Algebraic simplification • Strength reduction •Constant propagation •Copy propagation •Dead code elimination •Inlining and specialization • Recursive function inlining •Tail call elimination •Common subexpression elimination Stephen Chong, Harvard University 3 Optimizations •The code generated by our OAT compiler so far is pretty inefficient. •Lots of redundant moves. •Lots of unnecessary arithmetic instructions. •Consider this OAT program: int foo(int w) { var x = 3 + 5; var y = x * w; var z = y - 0; return z * 4; } Stephen Chong, Harvard University 4 Unoptimized vs. Optimized Output .globl _foo _foo: •Hand optimized code: pushl %ebp movl %esp, %ebp _foo: subl $64, %esp shlq $5, %rdi __fresh2: movq %rdi, %rax leal -64(%ebp), %eax ret movl %eax, -48(%ebp) movl 8(%ebp), %eax •Function foo may be movl %eax, %ecx movl -48(%ebp), %eax inlined by the compiler, movl %ecx, (%eax) movl $3, %eax so it can be implemented movl %eax, -44(%ebp) movl $5, %eax by just one instruction! movl %eax, %ecx addl %ecx, -44(%ebp) leal -60(%ebp), %eax movl %eax, -40(%ebp) movl -44(%ebp), %eax Stephen Chong,movl Harvard %eax,University %ecx 5 Why do we need optimizations? •To help programmers… •They write modular, clean, high-level programs •Compiler generates efficient, high-performance assembly •Programmers don’t write optimal code •High-level languages make avoiding redundant computation inconvenient or impossible •e.g.
    [Show full text]
  • A Formally-Verified Alias Analysis
    A Formally-Verified Alias Analysis Valentin Robert1;2 and Xavier Leroy1 1 INRIA Paris-Rocquencourt 2 University of California, San Diego [email protected], [email protected] Abstract. This paper reports on the formalization and proof of sound- ness, using the Coq proof assistant, of an alias analysis: a static analysis that approximates the flow of pointer values. The alias analysis con- sidered is of the points-to kind and is intraprocedural, flow-sensitive, field-sensitive, and untyped. Its soundness proof follows the general style of abstract interpretation. The analysis is designed to fit in the Comp- Cert C verified compiler, supporting future aggressive optimizations over memory accesses. 1 Introduction Alias analysis. Most imperative programming languages feature pointers, or object references, as first-class values. With pointers and object references comes the possibility of aliasing: two syntactically-distinct program variables, or two semantically-distinct object fields can contain identical pointers referencing the same shared piece of data. The possibility of aliasing increases the expressiveness of the language, en- abling programmers to implement mutable data structures with sharing; how- ever, it also complicates tremendously formal reasoning about programs, as well as optimizing compilation. In this paper, we focus on optimizing compilation in the presence of pointers and aliasing. Consider, for example, the following C program fragment: ... *p = 1; *q = 2; x = *p + 3; ... Performance would be increased if the compiler propagates the constant 1 stored in p to its use in *p + 3, obtaining ... *p = 1; *q = 2; x = 4; ... This optimization, however, is unsound if p and q can alias.
    [Show full text]
  • Cross-Platform Language Design
    Cross-Platform Language Design THIS IS A TEMPORARY TITLE PAGE It will be replaced for the final print by a version provided by the service academique. Thèse n. 1234 2011 présentée le 11 Juin 2018 à la Faculté Informatique et Communications Laboratoire de Méthodes de Programmation 1 programme doctoral en Informatique et Communications École Polytechnique Fédérale de Lausanne pour l’obtention du grade de Docteur ès Sciences par Sébastien Doeraene acceptée sur proposition du jury: Prof James Larus, président du jury Prof Martin Odersky, directeur de thèse Prof Edouard Bugnion, rapporteur Dr Andreas Rossberg, rapporteur Prof Peter Van Roy, rapporteur Lausanne, EPFL, 2018 It is better to repent a sin than regret the loss of a pleasure. — Oscar Wilde Acknowledgments Although there is only one name written in a large font on the front page, there are many people without which this thesis would never have happened, or would not have been quite the same. Five years is a long time, during which I had the privilege to work, discuss, sing, learn and have fun with many people. I am afraid to make a list, for I am sure I will forget some. Nevertheless, I will try my best. First, I would like to thank my advisor, Martin Odersky, for giving me the opportunity to fulfill a dream, that of being part of the design and development team of my favorite programming language. Many thanks for letting me explore the design of Scala.js in my own way, while at the same time always being there when I needed him.
    [Show full text]
  • Practical and Accurate Low-Level Pointer Analysis
    Practical and Accurate Low-Level Pointer Analysis Bolei Guo Matthew J. Bridges Spyridon Triantafyllis Guilherme Ottoni Easwaran Raman David I. August Department of Computer Science, Princeton University {bguo, mbridges, strianta, ottoni, eraman, august}@princeton.edu Abstract High−Level IR Low−Level IR Pointer SuperBlock .... Inlining Opti Scheduling .... Analysis Formation Pointer analysis is traditionally performed once, early Source Machine Code Code in the compilation process, upon an intermediate repre- Lowering sentation (IR) with source-code semantics. However, per- forming pointer analysis only once at this level imposes a Figure 1. Traditional compiler organization phase-ordering constraint, causing alias information to be- char A[10],B[10],C[10]; . come stale after subsequent code transformations. More- foo() { int i; over, high-level pointer analysis cannot be used at link time char *p; or run time, where the source code is unavailable. for (i=0;i<10;i++) { if (...) 1: p = A 2: p = B 1: p = A 2: p = B This paper advocates performing pointer analysis on a 1: p = A; 3': C[i] = p[i] 3: C[i] = p[i] else low-level intermediate representation. We present the first 2: p = B; 4': A[i] = ... 4: A[i] = ... 3: C[i] = p[i]; context-sensitive and partially flow-sensitive points-to anal- 4: A[i] = ...; 3: C[i] = p[i] } 4: A[i] = ... ysis designed to operate at the assembly level. As we will } demonstrate, low-level pointer analysis can be as accurate (a) Source code (b) Source code CFG (c) Transformed code CFG as high-level analysis. Additionally, our low-level pointer analysis also enables a quantitative comparison of prop- agating high-level pointer analysis results through subse- Figure 2.
    [Show full text]
  • Phase-Ordering in Optimizing Compilers
    Phase-ordering in optimizing compilers Matthieu Qu´eva Kongens Lyngby 2007 IMM-MSC-2007-71 Technical University of Denmark Informatics and Mathematical Modelling Building 321, DK-2800 Kongens Lyngby, Denmark Phone +45 45253351, Fax +45 45882673 [email protected] www.imm.dtu.dk Summary The “quality” of code generated by compilers largely depends on the analyses and optimizations applied to the code during the compilation process. While modern compilers could choose from a plethora of optimizations and analyses, in current compilers the order of these pairs of analyses/transformations is fixed once and for all by the compiler developer. Of course there exist some flags that allow a marginal control of what is executed and how, but the most important source of information regarding what analyses/optimizations to run is ignored- the source code. Indeed, some optimizations might be better to be applied on some source code, while others would be preferable on another. A new compilation model is developed in this thesis by implementing a Phase Manager. This Phase Manager has a set of analyses/transformations available, and can rank the different possible optimizations according to the current state of the intermediate representation. Based on this ranking, the Phase Manager can decide which phase should be run next. Such a Phase Manager has been implemented for a compiler for a simple imper- ative language, the while language, which includes several Data-Flow analyses. The new approach consists in calculating coefficients, called metrics, after each optimization phase. These metrics are used to evaluate where the transforma- tions will be applicable, and are used by the Phase Manager to rank the phases.
    [Show full text]
  • Dead Code Elimination Based Pointer Analysis for Multithreaded Programs
    Journal of the Egyptian Mathematical Society (2012) 20, 28–37 Egyptian Mathematical Society Journal of the Egyptian Mathematical Society www.etms-eg.org www.elsevier.com/locate/joems ORIGINAL ARTICLE Dead code elimination based pointer analysis for multithreaded programs Mohamed A. El-Zawawy Department of Mathematics, Faculty of Science, Cairo University, Giza 12316, Egypt Available online 2 February 2012 Abstract This paper presents a new approach for optimizing multitheaded programs with pointer constructs. The approach has applications in the area of certified code (proof-carrying code) where a justification or a proof for the correctness of each optimization is required. The optimization meant here is that of dead code elimination. Towards optimizing multithreaded programs the paper presents a new operational semantics for parallel constructs like join-fork constructs, parallel loops, and conditionally spawned threads. The paper also presents a novel type system for flow-sensitive pointer analysis of multithreaded pro- grams. This type system is extended to obtain a new type system for live-variables analysis of mul- tithreaded programs. The live-variables type system is extended to build the third novel type system, proposed in this paper, which carries the optimization of dead code elimination. The justification mentioned above takes the form of type derivation in our approach. ª 2011 Egyptian Mathematical Society. Production and hosting by Elsevier B.V. All rights reserved. 1. Introduction (a) concealing suspension caused by some commands, (b) mak- ing it easier to build huge software systems, (c) improving exe- One of the mainstream programming approaches today is mul- cution of programs specially those that are executed on tithreading.
    [Show full text]
  • Dataflow Analysis: Constant Propagation
    Dataflow Analysis Monday, November 9, 15 Program optimizations • So far we have talked about different kinds of optimizations • Peephole optimizations • Local common sub-expression elimination • Loop optimizations • What about global optimizations • Optimizations across multiple basic blocks (usually a whole procedure) • Not just a single loop Monday, November 9, 15 Useful optimizations • Common subexpression elimination (global) • Need to know which expressions are available at a point • Dead code elimination • Need to know if the effects of a piece of code are never needed, or if code cannot be reached • Constant folding • Need to know if variable has a constant value • So how do we get this information? Monday, November 9, 15 Dataflow analysis • Framework for doing compiler analyses to drive optimization • Works across basic blocks • Examples • Constant propagation: determine which variables are constant • Liveness analysis: determine which variables are live • Available expressions: determine which expressions are have valid computed values • Reaching definitions: determine which definitions could “reach” a use Monday, November 9, 15 Example: constant propagation • Goal: determine when variables take on constant values • Why? Can enable many optimizations • Constant folding x = 1; y = x + 2; if (x > z) then y = 5 ... y ... • Create dead code x = 1; y = x + 2; if (y > x) then y = 5 ... y ... Monday, November 9, 15 Example: constant propagation • Goal: determine when variables take on constant values • Why? Can enable many optimizations • Constant folding x = 1; x = 1; y = x + 2; y = 3; if (x > z) then y = 5 if (x > z) then y = 5 ... y ... ... y ... • Create dead code x = 1; y = x + 2; if (y > x) then y = 5 ..
    [Show full text]
  • Compiler-Based Code-Improvement Techniques
    Compiler-Based Code-Improvement Techniques KEITH D. COOPER, KATHRYN S. MCKINLEY, and LINDA TORCZON Since the earliest days of compilation, code quality has been recognized as an important problem [18]. A rich literature has developed around the issue of improving code quality. This paper surveys one part of that literature: code transformations intended to improve the running time of programs on uniprocessor machines. This paper emphasizes transformations intended to improve code quality rather than analysis methods. We describe analytical techniques and specific data-flow problems to the extent that they are necessary to understand the transformations. Other papers provide excellent summaries of the various sub-fields of program analysis. The paper is structured around a simple taxonomy that classifies transformations based on how they change the code. The taxonomy is populated with example transformations drawn from the literature. Each transformation is described at a depth that facilitates broad understanding; detailed references are provided for deeper study of individual transformations. The taxonomy provides the reader with a framework for thinking about code-improving transformations. It also serves as an organizing principle for the paper. Copyright 1998, all rights reserved. You may copy this article for your personal use in Comp 512. Further reproduction or distribution requires written permission from the authors. 1INTRODUCTION This paper presents an overview of compiler-based methods for improving the run-time behavior of programs — often mislabeled code optimization. These techniques have a long history in the literature. For example, Backus makes it quite clear that code quality was a major concern to the implementors of the first Fortran compilers [18].
    [Show full text]
  • Fast Online Pointer Analysis
    Fast Online Pointer Analysis MARTIN HIRZEL IBM Research DANIEL VON DINCKLAGE and AMER DIWAN University of Colorado and MICHAEL HIND IBM Research Pointer analysis benefits many useful clients, such as compiler optimizations and bug finding tools. Unfortunately, common programming language features such as dynamic loading, reflection, and foreign language interfaces, make pointer analysis difficult. This article describes how to deal with these features by performing pointer analysis online during program execution. For example, dynamic loading may load code that is not available for analysis before the program starts. Only an online analysis can analyze such code, and thus support clients that optimize or find bugs in it. This article identifies all problems in performing Andersen’s pointer analysis for the full Java language, presents solutions to these problems, and uses a full implementation of the solutions in a Java virtual machine for validation and performance evaluation. Our analysis is fast: On average over our benchmark suite, if the analysis recomputes points-to results upon each program change, most analysis pauses take under 0.1 seconds, and add up to 64.5 seconds. Categories and Subject Descriptors: D.3.4 [Programming Languages]: Processors—Compilers General Terms: Algorithms, Languages Additional Key Words and Phrases: Pointer analysis, class loading, reflection, native interface ACM Reference Format: Hirzel, M., von Dincklage, D., Diwan, A., and Hind, M. 2007. Fast online pointer analysis. ACM Trans. Program. Lang. Syst. 29, 2, Article 11 (April 2007), 55 pages. DOI = 10.1145/1216374. 1216379 http://doi.acm.org/10.1145/1216374.1216379. A preliminary version of parts of this article appeared in the European Conference on Object- Oriented Programming 2004.
    [Show full text]