Ahead-of-time compilation
This article includes a list of general references, but it lacks sufficient corresponding inline citations. (February 2014) |
Program execution |
---|
General concepts |
Types of code |
Compilation strategies |
|
Notable runtimes |
|
Notable compilers & toolchains |
|
In computer science, ahead-of-time compilation (AOT compilation) is the act of
Most often, it is associated with the act of compiling a higher-level programming language such as C or C++, or an intermediate representation such as Java bytecode or .NET Framework Common Intermediate Language (CIL) code, into a native (system-dependent) machine code so that the resulting binary file can execute natively, just like a standard native compiler. When being used in this specific context, it is often seen as an opposite of just-in-time (JIT) compiling.
Speaking more generally, the target languages of an AOT compilation are not necessarily specific to native machine code but are defined rather arbitrarily. Some academic papers use this word to mean the act of compiling the Java bytecode to C[1] or the timing when optimization pipeline are performed.[2] An academic project[3] uses this word to mean the act of pre-compiling JavaScript to a machine-dependent optimized IR for V8 (JavaScript engine)[4] and to a machine independent bytecode for JavaScriptCore.[5] Some industrial language implementations (e.g. Clojure[6] and Hermes JavaScript engine[7]) use this word to mean the act of pre-compiling the source language to VM specific bytecode. Angular (web framework) uses this word to mean converting its HTML template and TypeScript to JavaScript.[8]
In fact, since all
Reduced runtime overhead
Some programming languages with a managed code runtime that can be compiled to an intermediate representation use just-in-time (JIT) compiling. This briefly compiles intermediate code into machine code for a native run while the intermediate code is executing which may slow an application's performance. Ahead-of-time compiling eliminates the need for this step by occurring before execution rather than during execution.
Ahead-of-time compiling for
In most situations with fully AOT compiled programs and libraries, it is possible to remove part of a
Performance trade-offs
AOT compilers can perform complex and advanced code
Further, JIT compilers can speculatively optimize hot code by making assumptions on the code. The generated code can be deoptimized if a speculative assumption later proves wrong. Such operation slows the performance of the running software until code is optimized again by adaptive optimization. An AOT compiler cannot make such assumptions and needs to infer as much information as possible at compile time. It needs to resort to less specialized code because it cannot know what types will go through a method. Such problems can be alleviated by profile-guided optimizations. But even in this case, the generated code cannot be adapted dynamically to the changing runtime profile as a JIT compiler would do.
Storage trade-offs
This section needs expansion. You can help by adding to it. (May 2021) |
See also
- asm.js compiler (JavaScript)
- Bartok (CIL)
- Excelsior JET (Java)
- GNU Compiler for Java
- IL2CPU (CIL)
- Native Image Generator (CIL)
- RubyMotion (Ruby)
References
- S2CID 15591457.
- S2CID 18546907.
- S2CID 2338849.
- ^ ispras/v8-aotc, Ivannikov Institute for System Programming of the Russian Academy of Sciences, 2021-01-30, retrieved 2021-03-17
- ^ ispras/webkit-aotc, Ivannikov Institute for System Programming of the Russian Academy of Sciences, 2021-01-30, retrieved 2021-03-17
- ^ "Clojure - Ahead-of-time Compilation and Class Generation". clojure.org. Retrieved 2021-03-17.
- ^ "Hermes: A new open source JavaScript engine optimized for mobile apps". Facebook Engineering. 2019-07-12. Retrieved 2021-03-17.
- ^ "Angular". angular.io. Retrieved 2021-03-17.
External links
- Speed: NGen Revs Up Your Performance with Powerful New Features – MSDN Magazine, April 2005
- Mono AOT
- Excelsior JET – Certified Java SE Implementation with AOT compiler
- GNU Compiler for Java
- AOT compilation of asm.js
- Real-time Java, Part 2: Comparing compilation techniques – IBM developerWorks, April 2007
- Improving Swing Performance: JIT vs AOT Compilation – LinuxWorld Magazine, November 2004 Archived 2008-06-12 at the Wayback Machine
- Manta