Communication and concurrency
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Trace-Based Abstract Interpretation of Operational Semantics
Lisp and Symbolic Computation
Abstract interpretation of trace semantics for concurrent calculi
Information Processing Letters
Dynamo: a transparent dynamic optimization system
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
Systematic design of program transformation frameworks by abstract interpretation
POPL '02 Proceedings of the 29th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
POPL '77 Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Constructive design of a hierarchy of semantics of a transition system by abstract interpretation
Theoretical Computer Science
Systematic design of program analysis frameworks
POPL '79 Proceedings of the 6th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Class analyses as abstract interpretations of trace semantics
ACM Transactions on Programming Languages and Systems (TOPLAS)
Symbolic transfer function-based approaches to certified compilation
Proceedings of the 31st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
HotpathVM: an effective JIT compiler for resource-constrained devices
Proceedings of the 2nd international conference on Virtual execution environments
The trace partitioning abstract domain
ACM Transactions on Programming Languages and Systems (TOPLAS) - Special Issue ESOP'05
Class invariants as abstract interpretation of trace semantics
Computer Languages, Systems and Structures
Trace-based just-in-time type specialization for dynamic languages
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
Tracing the meta-level: PyPy's tracing JIT compiler
Proceedings of the 4th workshop on the Implementation, Compilation, Optimization of Object-Oriented Languages and Programming Systems
SPUR: a trace-based JIT compiler for CIL
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
The essence of compiling with traces
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Allocation removal by partial evaluation in a tracing JIT
Proceedings of the 20th ACM SIGPLAN workshop on Partial evaluation and program manipulation
Generalized just-in-time trace compilation using a parallel task farm in a dynamic binary translator
Proceedings of the 32nd ACM SIGPLAN conference on Programming language design and implementation
Hi-index | 0.00 |
Tracing just-in-time compilation is a popular compilation schema for the efficient implementation of dynamic languages, which is commonly used for JavaScript, Python, and PHP. It relies on two key ideas. First, it monitors the execution of the program to detect so-called hot paths, i.e., the most frequently executed paths. Then, it uses some store information available at runtime to optimize hot paths. The result is a residual program where the optimized hot paths are guarded by sufficient conditions ensuring the equivalence of the optimized path and the original program. The residual program is persistently mutated during its execution, e.g., to add new optimized paths or to merge existing paths. Tracing compilation is thus fundamentally different than traditional static compilation. Nevertheless, despite the remarkable practical success of tracing compilation, very little is known about its theoretical foundations. We formalize tracing compilation of programs using abstract interpretation. The monitoring (viz., hot path detection) phase corresponds to an abstraction of the trace semantics that captures the most frequent occurrences of sequences of program points together with an abstraction of their corresponding stores, e.g., a type environment. The optimization (viz., residual program generation) phase corresponds to a transform of the original program that preserves its trace semantics up to a given observation as modeled by some abstraction. We provide a generic framework to express dynamic optimizations and to prove them correct. We instantiate it to prove the correctness of dynamic type specialization. We show that our framework is more general than a recent model of tracing compilation introduced in POPL~2011 by Guo and Palsberg (based on operational bisimulations). In our model we can naturally express hot path reentrance and common optimizations like dead-store elimination, which are either excluded or unsound in Guo and Palsberg's framework.