Escape analysis

From Wikipedia, the free encyclopedia
Jump to: navigation, search

In programming language compiler optimization theory, escape analysis is a method for determining the dynamic scope of pointers. It is related to pointer analysis and shape analysis.

When a variable (or an object) is allocated in a subroutine, a pointer to the variable can escape to other threads of execution, or to calling subroutines. If an implementation uses tail call optimization (usually required for functional languages), objects may also be seen as escaping to called subroutines. If a language supports first-class continuations (as do Scheme and Standard ML of New Jersey), portions of the call stack may also escape.

If a subroutine allocates an object and returns a pointer to it, the object can be accessed from undetermined places in the program — the pointer has "escaped". Pointers can also escape if they are stored in global variables or other data structures that, in turn, escape the current procedure.

Escape analysis determines all the places where a pointer can be stored and whether the lifetime of the pointer can be proven to be restricted only to the current procedure and/or thread.

Optimizations[edit]

A compiler can use the results of escape analysis as a basis for optimizations:[1]

  • Converting heap allocations to stack allocations. If an object is allocated in a subroutine, and a pointer to the object never escapes, the object may be a candidate for stack allocation instead of heap allocation.
  • Synchronization elision. If an object is found to be accessible from one thread only, operations on the object can be performed without synchronization.
  • Breaking up objects or scalar replacement. An object may be found to be accessed in ways that do not require the object to exist as a sequential memory structure. This may allow parts (or all) of the object to be stored in CPU registers instead of in memory.

Practical considerations[edit]

In object-oriented programming languages, dynamic compilers are particularly good candidates for performing escape analysis. In traditional static compilation, method overriding can make escape analysis impossible, as any called method might be overridden by a version that allows a pointer to escape. Dynamic compilers can perform escape analysis using the available information on overloading, and re-do the analysis when relevant methods are overridden by dynamic code loading.[1]

The popularity of the Java programming language has made escape analysis a target of interest. Java's combination of heap-only object allocation, built-in threading, and the Sun HotSpot dynamic compiler creates a candidate platform for escape analysis related optimizations (see Escape analysis in Java). Escape analysis is implemented in Java Standard Edition 6.

Example (Java)[edit]

class MainClass {
  public static void main(String[] args) {
    aMethod();
  }
  public static void aMethod()
  {
    A aObj = new A();
    B bObj = new B();
    bObj.doSomething(aObj);
  }
}
 
class A {
}
 
class B {
  private A a;
  public void doSomething( A a ) {
    this.a = a;
  }
}

In this example, two objects are created, and one of them is given as an argument to a method of another. The method doSomething() stores a reference to a received A object. If the B object was on the heap then the reference to A would escape. But in this case a compiler can determine, with escape analysis, that the B object itself does not escape the invocation of aMethod(). Which implies that a reference to A cannot escape either. So the compiler can safely allocate both objects on the stack.

Examples (Scheme)[edit]

In the following example, the vector p does not escape into g, so it can be allocated on the stack and then removed from the stack before calling g.

(define (f x)
   (let ((p (make-vector 10000)))
      (fill-vector-with-good-stuff p)
      (g (vector-ref p 7023))))

If, however, we had

(define (f x)
   (let ((p (make-vector 10000)))
      (fill-vector-with-good-stuff p)
      (g p)))

then either p would need to be allocated on the heap or (if g is known to the compiler when f is compiled, and behaves well) allocated on the stack in such a fashion that it can remain in place when g is called.

If continuations are used to implement exception-like control structures, escape analysis can often detect this to avoid having to actually allocate a continuation and copy the call stack into it. For example, in

;;Reads scheme objects entered by the user. If all of them are numbers,
;;returns a list containing all of them in order. If the user enters one that
;;is not a number, immediately returns #f.
(define (getnumlist)
  (call/cc (lambda (continuation)
    (define (get-numbers)
       (let ((next-object (read)))
          (cond
             ((eof-object? next-object) '())
             ((number? next-object) (cons next-object (get-numbers)))
             (else (continuation #f)))))
    (get-numbers))))

escape analysis will determine that the continuation captured by call/cc doesn't escape, so no continuation structure needs to be allocated, and invoking the continuation by calling continuation can be implemented by truncating the stack.

See also[edit]

References[edit]

  1. ^ a b T. Kotzmann and H. Mössenböck, “Escape analysis in the context of dynamic compilation and deoptimization,” in Proceedings of the 1st ACM/USENIX international conference on Virtual execution environments, New York, NY, USA, 2005, pp. 111–120.