Native Code Optimization from mzc

Compiling a program to native code with mzc can provide significant speedups compared to interpreting byte codes (or running the program directly from source code) for certain kinds of programs. The speedup from native code compilation is typically due to two optimizations:

• Loop Optimization -- When mzc statically detects a tail-recursive loop, it compiles the Scheme loop to a C loop that has no interpreter overhead. For example, given the program

    (letrec ([odd (lambda (x) 
                    (if (zero? x) 
                        #f 
                        (even (sub1 x))))] 
             [even (lambda (x) 
                     (if (zero? x)
  
                         (odd (sub1 x))))]) 
      (odd 40000)) 
  

  mzc can detect the odd-even loop and produce native code that runs twice as fast as byte code interpretation. In contrast, given a similar program using top-level definitions,

    (define (odd x) ...)
    (define (even x) ...) 
  

  the compiler cannot assume an odd-even loop, because the global variables odd and even can be redefined at any time. Note that defined variables in a unit module are lexically scoped like letrec variables, and unit definitions therefore permit loop optimizations.
• Primitive Inlining -- When mzc encounters the application of certain primitives, it inlines the primitive procedure. However, the compiler must be certain that a variable reference will resolve to a primitive procedure when the code is loaded into MzScheme. In the preceding example, the compiler cannot inline the application of sub1 because the global variable sub1 might be redefined. To encourage the inlining of primitives--which produces native code that runs 30 times faster than byte code interpretation for the preceding example--the programmer has three options:
  • Use #% keywords -- If sub1 is replaced in the preceding example by #%sub1, add1 is replaced by #%add1, and zero? is replaced by #%zero?, then the compiler inlines each of the primitives.
  • Use the --prim flag -- The --prim flag alters the semantics of the langugage for compilation such that every reference to a global variable that is built into MzScheme is converted to its keyword form. Thus, specifying the --prim flag causes mzc to automatically convert sub1 to #%sub1, etc.
  • Use units (MzScheme modules) -- If the original example is encapsulated in a unit, then each primitive name, such as sub1, is guranteed to access the primitive procedure (assuming that the name is not lexically bound). The ``unitized'' version of the preceding program follows:

      (define oe-unit 
        (unit (import) (export) ; import nothing, export nothing 
          (letrec ([odd (lambda (x) 
                          (if (zero? x) 
                              #f 
                              (even (sub1 x))))] 
                   [even (lambda (x) 
                           (if (zero? x)
    
                               (odd (sub1 x))))]) 
            (odd 40000)))) 
      (invoke-unit oe-unit) ; run the program 
    

Native code compilation rarely produces significant speedup for programs that are not loop-intensive, programs that are heavily object-oriented, programs that are allocation-intensive, or programs that exploit built-in procedures (e.g., list operations, regular expression matching, or file manipulations) to perform most of the program's work.