VMIL '17: "Accelerate JavaScript Applications ..."
Accelerate JavaScript Applications by Cross-Compiling to WebAssembly
Micha Reiser and Luc Bläser
(University of Applied Sciences Rapperswil, Switzerland)
Although the performance of today's JavaScript engines is sufficient for most web applications, faster and more predictable runtimes could be desired for performance-critical web code. Therefore, we present Speedy.js, a cross-compiler that translates JavaScript/TypeScript to WebAssembly, a new standard for native execution supported by all major browsers. Speedy.js only imposes minimal restrictions on the JavaScript code, namely that the performance-critical functions are wrapped in TypeScript and only engage a performance-optimal subset of the JavaScript language. With this approach, we manage to make compute-intense web code up to four times faster, while reducing runtime fluctuations to the half.
@InProceedings{VMIL17p10,
author = {Micha Reiser and Luc Bläser},
title = {Accelerate JavaScript Applications by Cross-Compiling to WebAssembly},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {10--17},
doi = {10.1145/3141871.3141873},
year = {2017},
}
Publisher's Version
Info
VMIL '17: "Fusing Method Handle Graphs ..."
Fusing Method Handle Graphs for Efficient Dynamic JVM Language Implementations
Shijie Xu, David Bremner, and Daniel Heidinga
(University of New Brunswick, Canada; IBM, Canada)
A Method Handle (MH) in JSR 292 (Supporting Dynamically Typed Languages on the JVM) is a typed, directly executable reference to an underlying method, constructor, or field, with optional method type transformations. Multiple connected MHs make up a Method Handle Graph (MHG), which transfers an invocation at a dynamic call site to real method implementations at runtime. Despite benefits that MHGs have for dynamic JVM language implementations, MHGs challenge existing JVM optimization because a) larger MHGs at call sites incur higher graph traversal costs at runtime; and b) JIT expenses, including profiling and compilation of individual MHs, increase along with the number of MHs. This paper proposes dynamic graph fusion to compile an MHG into another equivalent but simpler MHG (e.g., fewer MHs and edges), as well as related optimization opportunities (e.g., selection policy and inline caching). Graph fusion dynamically fuses bytecodes of internal MHs on hot paths, and then substitutes these internal MHs with the instance of the newly generated bytecodes at program runtime. The implementation consists of a template system and GraphJIT. The former emits source bytecodes for individual MHs, while the latter is a JIT compiler that fuses source bytecodes from templates on the bytecode level (i.e., both source code and target code are bytecodes). With the JRuby Micro-Indy benchmark from Computer Language Benchmark Game and JavaScript Octane benchmark on Nashorn, our results show that (a) the technique can reduce execution time of Micro-Indy and Octane benchmarks by 6.28% and 7.73% on average; b) it can speed up a typical MHG’s execution by 31.53% using Ahead-Of-Time (AOT) compilation; and (c) the technique reduces the number of MH JIT compilations by 52.1%.
@InProceedings{VMIL17p18,
author = {Shijie Xu and David Bremner and Daniel Heidinga},
title = {Fusing Method Handle Graphs for Efficient Dynamic JVM Language Implementations},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {18--27},
doi = {10.1145/3141871.3141874},
year = {2017},
}
Publisher's Version
VMIL '17: "Cross-ISA Debugging in Meta-circular ..."
Cross-ISA Debugging in Meta-circular VMs
Christos Kotselidis, Andy Nisbet, Foivos S. Zakkak, and Nikos Foutris
(University of Manchester, UK)
Extending current Virtual Machine implementations to new Instruction Set Architectures entails a significant programming and debugging effort. Meta-circular VMs add another level of complexity towards this aim since they have to compile themselves with the same compiler that is being extended. Therefore, having low-level debugging tools is of vital importance in decreasing development time and bugs introduced.
In this paper we describe our experiences in extending Maxine VM to the ARMv7 architecture. During that process, we developed a QEMU-based toolchain which enables us to debug a wide range of VM features in an automated way. The presented toolchain has been integrated with the JUNIT testing framework of Maxine VM and is capable of executing from simple assembly instructions to fully JIT compiled code. Furthermore, it is fully open-sourced and can be adapted to any other VMs seamlessly. Finally, we describe a compiler-assisted methodology that helps us identify, at runtime, faulty methods that generate no stack traces, in an automatic and fast manner.
@InProceedings{VMIL17p1,
author = {Christos Kotselidis and Andy Nisbet and Foivos S. Zakkak and Nikos Foutris},
title = {Cross-ISA Debugging in Meta-circular VMs},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {1--9},
doi = {10.1145/3141871.3141872},
year = {2017},
}
Publisher's Version
VMIL '17: "Fusing Method Handle Graphs ..."
Fusing Method Handle Graphs for Efficient Dynamic JVM Language Implementations
Shijie Xu, David Bremner, and Daniel Heidinga
(University of New Brunswick, Canada; IBM, Canada)
A Method Handle (MH) in JSR 292 (Supporting Dynamically Typed Languages on the JVM) is a typed, directly executable reference to an underlying method, constructor, or field, with optional method type transformations. Multiple connected MHs make up a Method Handle Graph (MHG), which transfers an invocation at a dynamic call site to real method implementations at runtime. Despite benefits that MHGs have for dynamic JVM language implementations, MHGs challenge existing JVM optimization because a) larger MHGs at call sites incur higher graph traversal costs at runtime; and b) JIT expenses, including profiling and compilation of individual MHs, increase along with the number of MHs. This paper proposes dynamic graph fusion to compile an MHG into another equivalent but simpler MHG (e.g., fewer MHs and edges), as well as related optimization opportunities (e.g., selection policy and inline caching). Graph fusion dynamically fuses bytecodes of internal MHs on hot paths, and then substitutes these internal MHs with the instance of the newly generated bytecodes at program runtime. The implementation consists of a template system and GraphJIT. The former emits source bytecodes for individual MHs, while the latter is a JIT compiler that fuses source bytecodes from templates on the bytecode level (i.e., both source code and target code are bytecodes). With the JRuby Micro-Indy benchmark from Computer Language Benchmark Game and JavaScript Octane benchmark on Nashorn, our results show that (a) the technique can reduce execution time of Micro-Indy and Octane benchmarks by 6.28% and 7.73% on average; b) it can speed up a typical MHG’s execution by 31.53% using Ahead-Of-Time (AOT) compilation; and (c) the technique reduces the number of MH JIT compilations by 52.1%.
@InProceedings{VMIL17p18,
author = {Shijie Xu and David Bremner and Daniel Heidinga},
title = {Fusing Method Handle Graphs for Efficient Dynamic JVM Language Implementations},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {18--27},
doi = {10.1145/3141871.3141874},
year = {2017},
}
Publisher's Version
VMIL '17: "Cross-ISA Debugging in Meta-circular ..."
Cross-ISA Debugging in Meta-circular VMs
Christos Kotselidis, Andy Nisbet, Foivos S. Zakkak, and Nikos Foutris
(University of Manchester, UK)
Extending current Virtual Machine implementations to new Instruction Set Architectures entails a significant programming and debugging effort. Meta-circular VMs add another level of complexity towards this aim since they have to compile themselves with the same compiler that is being extended. Therefore, having low-level debugging tools is of vital importance in decreasing development time and bugs introduced.
In this paper we describe our experiences in extending Maxine VM to the ARMv7 architecture. During that process, we developed a QEMU-based toolchain which enables us to debug a wide range of VM features in an automated way. The presented toolchain has been integrated with the JUNIT testing framework of Maxine VM and is capable of executing from simple assembly instructions to fully JIT compiled code. Furthermore, it is fully open-sourced and can be adapted to any other VMs seamlessly. Finally, we describe a compiler-assisted methodology that helps us identify, at runtime, faulty methods that generate no stack traces, in an automatic and fast manner.
@InProceedings{VMIL17p1,
author = {Christos Kotselidis and Andy Nisbet and Foivos S. Zakkak and Nikos Foutris},
title = {Cross-ISA Debugging in Meta-circular VMs},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {1--9},
doi = {10.1145/3141871.3141872},
year = {2017},
}
Publisher's Version
VMIL '17: "Cross-ISA Debugging in Meta-circular ..."
Cross-ISA Debugging in Meta-circular VMs
Christos Kotselidis, Andy Nisbet, Foivos S. Zakkak, and Nikos Foutris
(University of Manchester, UK)
Extending current Virtual Machine implementations to new Instruction Set Architectures entails a significant programming and debugging effort. Meta-circular VMs add another level of complexity towards this aim since they have to compile themselves with the same compiler that is being extended. Therefore, having low-level debugging tools is of vital importance in decreasing development time and bugs introduced.
In this paper we describe our experiences in extending Maxine VM to the ARMv7 architecture. During that process, we developed a QEMU-based toolchain which enables us to debug a wide range of VM features in an automated way. The presented toolchain has been integrated with the JUNIT testing framework of Maxine VM and is capable of executing from simple assembly instructions to fully JIT compiled code. Furthermore, it is fully open-sourced and can be adapted to any other VMs seamlessly. Finally, we describe a compiler-assisted methodology that helps us identify, at runtime, faulty methods that generate no stack traces, in an automatic and fast manner.
@InProceedings{VMIL17p1,
author = {Christos Kotselidis and Andy Nisbet and Foivos S. Zakkak and Nikos Foutris},
title = {Cross-ISA Debugging in Meta-circular VMs},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {1--9},
doi = {10.1145/3141871.3141872},
year = {2017},
}
Publisher's Version
VMIL '17: "Accelerate JavaScript Applications ..."
Accelerate JavaScript Applications by Cross-Compiling to WebAssembly
Micha Reiser and Luc Bläser
(University of Applied Sciences Rapperswil, Switzerland)
Although the performance of today's JavaScript engines is sufficient for most web applications, faster and more predictable runtimes could be desired for performance-critical web code. Therefore, we present Speedy.js, a cross-compiler that translates JavaScript/TypeScript to WebAssembly, a new standard for native execution supported by all major browsers. Speedy.js only imposes minimal restrictions on the JavaScript code, namely that the performance-critical functions are wrapped in TypeScript and only engage a performance-optimal subset of the JavaScript language. With this approach, we manage to make compute-intense web code up to four times faster, while reducing runtime fluctuations to the half.
@InProceedings{VMIL17p10,
author = {Micha Reiser and Luc Bläser},
title = {Accelerate JavaScript Applications by Cross-Compiling to WebAssembly},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {10--17},
doi = {10.1145/3141871.3141873},
year = {2017},
}
Publisher's Version
Info
VMIL '17: "Fusing Method Handle Graphs ..."
Fusing Method Handle Graphs for Efficient Dynamic JVM Language Implementations
Shijie Xu, David Bremner, and Daniel Heidinga
(University of New Brunswick, Canada; IBM, Canada)
A Method Handle (MH) in JSR 292 (Supporting Dynamically Typed Languages on the JVM) is a typed, directly executable reference to an underlying method, constructor, or field, with optional method type transformations. Multiple connected MHs make up a Method Handle Graph (MHG), which transfers an invocation at a dynamic call site to real method implementations at runtime. Despite benefits that MHGs have for dynamic JVM language implementations, MHGs challenge existing JVM optimization because a) larger MHGs at call sites incur higher graph traversal costs at runtime; and b) JIT expenses, including profiling and compilation of individual MHs, increase along with the number of MHs. This paper proposes dynamic graph fusion to compile an MHG into another equivalent but simpler MHG (e.g., fewer MHs and edges), as well as related optimization opportunities (e.g., selection policy and inline caching). Graph fusion dynamically fuses bytecodes of internal MHs on hot paths, and then substitutes these internal MHs with the instance of the newly generated bytecodes at program runtime. The implementation consists of a template system and GraphJIT. The former emits source bytecodes for individual MHs, while the latter is a JIT compiler that fuses source bytecodes from templates on the bytecode level (i.e., both source code and target code are bytecodes). With the JRuby Micro-Indy benchmark from Computer Language Benchmark Game and JavaScript Octane benchmark on Nashorn, our results show that (a) the technique can reduce execution time of Micro-Indy and Octane benchmarks by 6.28% and 7.73% on average; b) it can speed up a typical MHG’s execution by 31.53% using Ahead-Of-Time (AOT) compilation; and (c) the technique reduces the number of MH JIT compilations by 52.1%.
@InProceedings{VMIL17p18,
author = {Shijie Xu and David Bremner and Daniel Heidinga},
title = {Fusing Method Handle Graphs for Efficient Dynamic JVM Language Implementations},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {18--27},
doi = {10.1145/3141871.3141874},
year = {2017},
}
Publisher's Version
VMIL '17: "Cross-ISA Debugging in Meta-circular ..."
Cross-ISA Debugging in Meta-circular VMs
Christos Kotselidis, Andy Nisbet, Foivos S. Zakkak, and Nikos Foutris
(University of Manchester, UK)
Extending current Virtual Machine implementations to new Instruction Set Architectures entails a significant programming and debugging effort. Meta-circular VMs add another level of complexity towards this aim since they have to compile themselves with the same compiler that is being extended. Therefore, having low-level debugging tools is of vital importance in decreasing development time and bugs introduced.
In this paper we describe our experiences in extending Maxine VM to the ARMv7 architecture. During that process, we developed a QEMU-based toolchain which enables us to debug a wide range of VM features in an automated way. The presented toolchain has been integrated with the JUNIT testing framework of Maxine VM and is capable of executing from simple assembly instructions to fully JIT compiled code. Furthermore, it is fully open-sourced and can be adapted to any other VMs seamlessly. Finally, we describe a compiler-assisted methodology that helps us identify, at runtime, faulty methods that generate no stack traces, in an automatic and fast manner.
@InProceedings{VMIL17p1,
author = {Christos Kotselidis and Andy Nisbet and Foivos S. Zakkak and Nikos Foutris},
title = {Cross-ISA Debugging in Meta-circular VMs},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {1--9},
doi = {10.1145/3141871.3141872},
year = {2017},
}
Publisher's Version