Compilers: principles, techniques, and tools
Compilers: principles, techniques, and tools
Design patterns: elements of reusable object-oriented software
Design patterns: elements of reusable object-oriented software
C: a language for high-level, efficient, and machine-independent dynamic code generation
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Advanced compiler design and implementation
Advanced compiler design and implementation
MetaML and multi-stage programming with explicit annotations
Theoretical Computer Science - Partial evaluation and semantics-based program manipulation
Jumbo: run-time code generation for Java and its applications
Proceedings of the international symposium on Code generation and optimization: feedback-directed and runtime optimization
CodeBricks: code fragments as building blocks
Proceedings of the 2003 ACM SIGPLAN workshop on Partial evaluation and semantics-based program manipulation
Term rewriting with traversal functions
ACM Transactions on Software Engineering and Methodology (TOSEM)
Routine run-time code generation
OOPSLA '03 Companion of the 18th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Invited application paper: program generation considered easy
Proceedings of the 2004 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Optimizations in distributed run-time compilation
Optimizations in distributed run-time compilation
Program Transformation with Scoped Dynamic Rewrite Rules
Fundamenta Informaticae - Program Transformation: Theoretical Foundations and Basic Techniques. Part 2
CC'05 Proceedings of the 14th international conference on Compiler Construction
| Hi-index | 0.00 |
We describe our efforts to use rule-based programming to produce a model of Jumbo, a run-time program generation (RTPG) system for Java. Jumbo incorporates RTPG following the simple principle that the regular compiler - or, rather, its back-end - can be used both for ordinary, static compilation and for run-time compilation. This tends to produce a run-time compiler that is inefficient but potentially subject to improvement by partial evaluation. However, the complexity of the language and compiler have made it difficult for us to achieve actual optimization. The model, written in Maude, preserves all the essential ingredients of Jumbo, but operates on a simplified language, called Mumbo. The simplification in the language together with Maude's support for code rewriting has allowed us to make rapid progress. We discuss the model in detail, the kinds of optimizations we have obtained, and the impact on the Jumbo project.