The semantics of future and its use in program optimization
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Compiler correctness for parallel languages
FPCA '95 Proceedings of the seventh international conference on Functional programming languages and computer architecture
Communication and concurrency
Constraint systems for useless variable elimination
Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Dynamo: a transparent dynamic optimization system
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
Proving correctness of compiler optimizations by temporal logic
POPL '02 Proceedings of the 29th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Programming Approach to Computability
Programming Approach to Computability
Automatically proving the correctness of compiler optimizations
PLDI '03 Proceedings of the ACM SIGPLAN 2003 conference on Programming language design and implementation
A bisimulation for dynamic sealing
Proceedings of the 31st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Set constraints for destructive array update optimization
Journal of Functional Programming
A bisimulation for type abstraction and recursion
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Small bisimulations for reasoning about higher-order imperative programs
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A complete, co-inductive syntactic theory of sequential control and state
Proceedings of the 34th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Efficient bytecode verification and compilation in a virtual machine
Efficient bytecode verification and compilation in a virtual machine
Tracing for web 3.0: trace compilation for the next generation web applications
Proceedings of the 2009 ACM SIGPLAN/SIGOPS international conference on Virtual execution environments
Trace-based just-in-time type specialization for dynamic languages
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
Verified just-in-time compiler on x86
Proceedings of the 37th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Trace-based compilation in execution environments without interpreters
Proceedings of the 8th International Conference on the Principles and Practice of Programming in Java
SPUR: a trace-based JIT compiler for CIL
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
Dynamic elimination of overflow tests in a trace compiler
CC'11/ETAPS'11 Proceedings of the 20th international conference on Compiler construction: part of the joint European conferences on theory and practice of software
Reducing trace selection footprint for large-scale Java applications without performance loss
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
Swift: a register-based JIT compiler for embedded JVMs
VEE '12 Proceedings of the 8th ACM SIGPLAN/SIGOPS conference on Virtual Execution Environments
A trace-based Java JIT compiler retrofitted from a method-based compiler
CGO '11 Proceedings of the 9th Annual IEEE/ACM International Symposium on Code Generation and Optimization
A hybrid just-in-time compiler for android: comparing JIT types and the result of cooperation
Proceedings of the 2012 international conference on Compilers, architectures and synthesis for embedded systems
Parameter based constant propagation
SBLP'12 Proceedings of the 16th Brazilian conference on Programming Languages
Tracing compilation by abstract interpretation
Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages
Hi-index | 0.00 |
The technique of trace-based just-in-time compilation was introduced by Bala et al. and was further developed by Gal et al. It currently enjoys success in Mozilla Firefox's JavaScript engine. A trace-based JIT compiler leverages run-time profiling to optimize frequently-executed paths while enabling the optimized code to ``bail out'' to the original code when the path has been invalidated. This optimization strategy differs from those of other JIT compilers and opens the question of which trace optimizations are sound. In this paper we present a framework for reasoning about the soundness of trace optimizations, and we show that some traditional optimization techniques are sound when used in a trace compiler while others are unsound. The converse is also true: some trace optimizations are sound when used in a traditional compiler while others are unsound. So, traditional and trace optimizations form incomparable sets. Our setting is an imperative calculus for which tracing is explicitly spelled out in the semantics. We define optimization soundness via a notion of bisimulation, and we show that sound optimizations lead to confluence and determinacy of stores.