here - Stefan-Marr.de

9.5. Future Work
9.5.1. Support for Parallel Programming
Sec. 3.2.4.1 identified requirements for the support of parallel programming in
multi-language VMs. While this dissertation did not pursue the corresponding
research questions, they are relevant for the future. The required mechanisms
for adaptive optimization and monitoring are not yet widely supported
in VMs and could be beneficial to parallel programming and beyond. Thus,
future work will investigate how the optimization infrastructure, typically
related to just-in-time compilation, can be exposed to language and library
implementers. Related work in that direction is for instance the Graal project
of Oracle for the JVM [Würthinger, 2011]. Furthermore, future work needs to
investigate how runtime monitoring can be realized to enable flexible monitoring
of execution and instrumentation of code by language and library
implementers to gather the relevant information to perform adaptive optimizations
for a wide range of parallel programming techniques.
There is strong potential for such techniques to facilitate language implementation
on top of multi-language VMs to enable them to utilize the available
optimization infrastructure to gain optimal performance.
9.5.2. Support for Just-in-Time Compilation
Future work needs to develop a strategy to support the OMOP in just-in-time
(JIT) compiling VMs to enable its adoption in high-performance JVMs or CLI
runtimes.
One challenge with the OMOP is the notion of ownership. One of the design
goals was to enable the use of libraries in different domains. Thus, instead
of using a metaclass-based approach where the meta relation is based
on a predetermined relation with the metaclass, the OMOP uses a dynamic
solution based on object ownership.
However, for highly efficient native code, this flexibility is a problem, because
the code needs to account for changing owners of objects which could
preclude operations such as inlining that are necessary to achieve the desired
performance.
Nevertheless, it may be assumed that in common applications object graphs
and computations will be less dynamic than they potentially could be. Thus,
a JIT compiler could optimistically compile a method based on the currently
known object and ownership configuration. Standard compiler optimizations
could then be applied to inline the intercession handlers and remove the overhead
of reflective operations to obtain optimal code. Instead of performing
243