Routine Runtime Code Generation

1
Routine Run-time Code Generation

• Sam Kamin
• Univ. of Illinois _at_ Urbana-Champaign
• Onward! Workshop
• OOPSLA 2003

2
A paradox

• Program generation has long been touted as a
  powerful technique both for improving efficiency
  of programs and providing higher-level
  programming facilities
• Yet, program generation is not actually used very
  much in practice.

3
Our thesis

• We argue that the explanation for this paradox
  lies in two facts
• Compile-time code generators are limited in power
  and difficult to deploy.
• Programmers do not have an easy way to create
  run-time code generators.

? Programmers usually do not consider program
generation as an option.
4
Our thesis (cont.)

• To make code generation routine
• Need to provide a simple facility for application
  programmers to produce run-time code generators.
• Those code generators must be as easy to use as
  ordinary software components.

? Programmers would find numerous uses for such a
facility.
5
Outline of Talk

• Limitations of compile-time program generation
• Applications of programmer-defined run-time
  program generators
• Examples
• Jumbo a tool for creating run-time program
  generators in Java

6
Outline of Talk

• Limitations of compile-time program generation
• Applications of programmer defined run-time
  program generators
• Examples
• Jumbo a tool for creating run-time program
  generators in Java

7
Limitations of compile-time program generation

• Limited power
• For value-based optimizations, the first stage of
  data is rarely available at compile time, or even
  at load time. Rather, it becomes available early
  in the computation (but still at run-time), then
  survives for a long time.

8
Deployability

• Lesson from software component community
• Software component a chunk of code that can be
  deployed independently and is subject to
  composition by third parties.
• Examples subroutine and class libraries COM
  components Java applets
• Software components are binary units C.
  Szyperski
• Unlike program generators, software components
  are very widely used in practice.

9
Limitations of compile-time program generation
(cont.)

• Compile-time program generators not deployable,
  because they require a compiler, but
• Most computers dont have compilers.
• If they do, may not have correct version.
• If they do, may not have correct libraries
• If they do, may not have the libraries in the
  expected locations

10
Limitations of compile-time program generation
(cont.)

• Compile-time program generators require source
  code distribution
• Moral Program generators need to operate at run
  time, and have binary inputs and outputs.

11
Outline of Talk

• Limitations of compile-time program generation
• Applications of programmer defined run-time
  program generators
• Examples
• Jumbo a tool for creating run-time program
  generators in Java

12
Uses of Program Generation

• Value-based optimizations Staging run-time
  values, using earlier values to improve the
  efficiency of calculations on later values.
• Software adaptation Generating code appropriate
  for given platform and client
• Software architecture Generating glue to
  combine components

13
Uses of Program Generation (cont.)

• Programming idioms Directly implementing ideas
  like state machine, divide-and-conquer, etc.
• Domain-specific languages High-level operators
  for specific domains, implemented efficiently
• Mobile code Communicating generic code, but
  adapting it for efficiency

14
Programmer-written program generators

• Application programmers must be able to write
  program generators
• Many applications possible vendors can only
  supply a limited number
• Program generators can require a lot of
  parameters. General-purpose program generators
  are too complicated.

15
Outline of Talk

• Limitations of compile-time program generation
• Applications of programmer defined run-time
  program generators
• Examples
• Jumbo a tool for creating run-time program
  generators in Java

16
Compile-time program generation a simple method

• Java with quotation/antiquotation. Write
• lt . gt for .
• (except embedded newlines are allowed)
• lt (expr) --- gt for expr ---
• (expr an arbitrary expression of type String.)
• Add methods
• prog.generate() Compile prog
• prog.create(classname) Compile prog and
  create object of class classname
• Use Code as synonym for String.

17
Examples of quote/antiquote

• In Java program
• Code p lt class SimpleClass
• . . .
• gt
• p.generate()
• creates file SimpleClass.class, which can be used
  in other Java programs

18
Examples of quote/antiquote

• interface UsefulClass . . .
• Code p lt class SimpleClass
• implements UsefulClass
• . . .
• gt
• UsefulClass o (UsefulClass)p.create(Simple
  Class)
• creates file SimpleClass.class, and creates an
  object of that class, which can be used now.

19
Example Value-based optimization

• Classic example Dot product
• public static Dot codegenDot(double V1)
• Code c
• ltpublic class DotProd implements Dot
• public double dot(double V2)
• double product makeSumCode(V1,
  ltV2gt)
• return product
• gt
• return (Dot)c.create(DotProd)

20
Example Value-based optimization

• Classic example Dot product (cont.)
• public static Code makeSumCode (double V1,
• Code V2)
• Code sumcode lt0.0gt
• for (int i 0 i lt V1.length i)
• if (V1i ! 0.0)
• sumcode ltsumcode V1iV2igt
• return sumcode

21
Example Value-based optimization

• More complicated example Loop unrolling.
• Given loop body, can easily copy it several
  times. Difficulty arises when loop body depends
  upon iteration variable.
• Define

interface LoopIteration Code iteration (Code
i)
22
Example Loop unrolling
static Code unroll (Stmtfun F, Code i, int n)
if (n0) return lti 0gt else
return lt (unroll(F, i, n-1))
(F.iter(i)) i gt
23
Example Loop unrolling
Stmtfun F new Stmtfun () public Code
iter (String indx) return lt
System.out.println(indx) gt
Unroll.unroll(F, ltvgt, 5)
v 0 System.out.println(v) v
System.out.println(v) v System.out.println(v
) v
24
Example Loop unrolling

• Things get more complicated when partial
  unrolling is desired

public static Code unroll_part (
Code i, Code init, int incr, int
iterations, Stmtfun F, int BlockSize) int
loops iterations/BlockSize, leftover
iterationsBlockSize if (loops lt 2)
return unroll(i, init, incr, iterations, F)
else
25
Example Loop unrolling
return lt for (i init i lt
init(loopsBlockSizeincr))
(unroll(i, i, incr, BlockSize, F))
(unroll(i, i, incr, leftover, F)) gt
26
Example Loop unrolling
Unroll.unroll_part(ltigt, lt0gt, 1, 500, F, 6)
for (i0 ilt0498) System.out.println(i0)
System.out.println(i1) System.out.println(
i2) System.out.println(i3)
System.out.println(i4) System.out.println(i5)
i i6 System.out.println(i0)
System.out.println(i1) i i2
27
Example ifdefs
interface MachineType Code
getPlatformSpecificCode () Code
getOtherPlatformSpecificCode () ...
MachineType thisPlatform getThisPlatform()
Code platformSpecificCode lt class
GenericCode ... (thisPlatform.getPlaftorm
SpecificCode()) ... gt
platformSpecificCode.generate()
28
Example Polymorphism

• Can gain efficiency by generating specific
  versions of polymorphic code

Code vectorClassDefs ltpublic class
vname // vector class elttype
elements int numelements public
vname() . . . // constructor
public void add(elttype o) ... ...
gt
29
Example Polymorphism

• Use is similar to C templates
• Eliminates cost of unboxing if vector elements
  are primitive

(vector(ltintgt)) v
(newVector(ltintgt))
30
Example Programming idioms

• Could define, for example, finite-state machine
  generator

Transition s0 new Transition( new
Predicate () mkLetterPred(ch) 1,
new Action () ltaddToBuffer(ch)gt
), new Transition( ), new Transition(
) State st0 new State(s0)
31
Example Programming idioms

• Would create code you might hand-code

int theState 0 while (true) if
(in.empty()) return char ch in.next()
switch (theState) case 0 if (('a' lt ch
'z' gt ch) ('A' lt ch'
Z' gt ch)) addToBuffer(ch)
theState 1 . .
.
32
What to take from these examples

• Wide range of applications.
• Each application could be very complicated if
  done in full generality.
• Specific cases not difficult to write
• Also note particular use of strings never use
  any string destructors. (Strings are used in a
  functional style.)

33
Recap

• Program generators not hard to create.
• Must be deployable to be easily therefore,
  widely used
• If widely use, many would be created.

? Need way to make program generators operate at
binary level binary inputs and outputs.
34
Outline of Talk

• Limitations of compile-time program generation
• Applications of programmer defined run-time
  program generators
• Examples
• Jumbo a tool for creating run-time program
  generators in Java

35
Binary program generators

• Examples above worked by generating strings, then
  invoking compiler. But lesson from software
  components is that program generators must
  operate at a binary level in order to be easily
  deployed/widely used.
• Can overcome this problem by partially evaluating
  compiler

36
Using Partial Evaluation

• Given program fragment S, run compiler on S as
  much as possible, leaving some residual
  compilation. Deployable unit is this residual
  compiler.
• At run time, these residual compilers are
  combined and compilation finishes.

37
How to partially evaluate a compiler

• Short answer you cant. That is, no compiler
  for a realistic language can be partially
  evaluated to any meaningful extent.
• Complexity too great.
• For most fragments, correct compiler output is
  syntax error.

38
How to partially evaluate a compiler (cont.)

• Long answer Rewrite compiler in compositional
  form
• comp Program Fragment -gt Code
• comp(op(e1,e2)) compop(comp(e1), comp(e2))
• where Code machine language
• For example
• comp(while (cond) stmt)
• compwhile(comp(cond), comp(stmt))

39
(No Transcript)
40
(No Transcript)
41
(No Transcript)
42
(No Transcript)
43
(No Transcript)
44
(No Transcript)
45
(No Transcript)
46
(No Transcript)
47
(No Transcript)
48
Compositional compilation

• Compositionality implies
• Can compile fragments separately.
• More crucially, can compile programs with holes.
  Define
• comp Program-w/-hole ? Code ? Code
• comp(P?)(c) comp(PA), where A is
• any program such that comp(A) c.

49
Code ? Machine Language

• For compositionality to be possible, range of
  compilation function must be richer than machine
  language, e.g.
• Code Environment ?
• machine language
• where Environment gives contextual information
  about variable types, etc.
• Then need codegen Code ? mach lang

50
Jumbo

• Jumbo is a run-time code generation system for
  Java, based on principles just outlined. (Code
  class defines function objects from Environment
  to JVM.)
• Examples given above run with some minor
  modifications (for parsing reasons) and generate
  code dynamically.
• Obtain at shasta.cs.uiuc.edu/Jumbo

51
Stuff we dont know

• How to type-check. (N.B. absence of compile-time
  type-checking in Jumbo is at least as much a
  feature as a bug!)
• More generally, how to guarantee safety of code
  built from many fragments.
• How to optimize code generation.
• How to write (efficient) optimizing compilers in
  compositional form.

52
Related Work

• Partial evaluation systems, C, DynJava all
  limit programmers power, e.g. cannot define new
  types dynamically.
• IP More powerful, but source (AST) level, and
  very difficult to manage.
• Lisp macros In interpretive languages,
  run-time/compile-time distinction is mooted.

53
Conclusion

• The decades-old paradigm of object code
  executable code is outdated. The paradigm we
  propose in this paper is object code
  executable program generator. Similarly,
  software component should be program that,
  when appropriately invoked by a client, generates
  machine language useful to the client.