Da Vinci Machine

Multi Language Virtual Machine
Developer(s) Sun Microsystems
Operating system Cross-platform
Type Library
License GPL+linking exception
Website openjdk.java.net/projects/mlvm

The Da Vinci Machine, also called the Multi Language Virtual Machine was a Sun Microsystems project aiming to prototype the extension of the Java Virtual Machine to add support for dynamic languages.

It was already possible to run dynamic languages on top of the JVM, but the goal is to ease new dynamic language implementations and increase their performance. This project was the reference implementation of JSR 292 (Supporting Dynamically Typed Languages on the Java Platform).[1]

History

Prior to Java 7, the Java Virtual Machine had no built-in support for dynamically typed languages:

JSR 292 (Supporting Dynamically Typed Languages on the Java Platform)[1] proposes to:

Following the success of the JRuby Java implementation, the Da Vinci project was started at the end of January 2008.[4] The capabilities experimented by Da Vinci were planned to be added to Java 7. It aims to prototype this JSR, but also other lower-priority extensions.[5] The first working prototype, developed as a patch on OpenJDK, was announced and made available on end of August 2008.[6][7][8]

Since then, the JRuby team has successfully wired dynamic invocation in their codebase. Dynamic invocation shipped with the 1.1.5 release, and will be disabled on JVMs without invokedynamic capabilities.[9]

Since then, the project has been integrated in the JDK 7 codebase[10] and then integrated in the Java 7 release.

Architecture

Dynamic invocation is built on the fact that, even if Java is a strongly static language at the language level, the type information is much less prevalent at the bytecode level.

However, dynamic languages implementations need to be able to use just-in-time compilation (rather than reflection) to achieve a good performance, and so to compile scripts to bytecode at runtime. To be allowed to be run by the Java Virtual Machine, these bytecodes must be verified prior to the execution, and the verifier check that the types are static throughout the code. It leads to these implementations having to create many different bytecodes for the different contexts of a method call, each time the signature of the arguments change.

This not only uses a lot of memory, but also fills a memory area called Permanent Generation, a part of the heap used by the JVM to store information about classes. Memory used in this area is never garbage collected because it stores immutable data in the context of Java programs; and because of that, dynamic languages implementations can only compile a small part of the scripts.[11]

JSR 292 proposes to:

See also

References

  1. 1 2 see JSR 292
  2. ↑ Nutter, Charles (2007-01-03). "InvokeDynamic: Actually Useful?". Retrieved 2008-02-06.
  3. 1 2 Ed Ort (July 2009). "New JDK 7 Feature: Support for Dynamically Typed Languages in the Java Virtual Machine". Retrieved 2009-07-26.
  4. ↑ Krill, Paul (2008-01-31). "Sun's Da Vinci Machine broadens JVM coverage". Retrieved 2008-02-06.
  5. ↑ "Sub-Projects and Investigations". Sun Microsystems. 2007. Retrieved 2008-02-06.
  6. ↑ Rose, John (2008-08-26). "Happy International Invokedynamic Day!". Retrieved 2008-09-03.
  7. ↑ Rose, John (2008-09-02). "Happy International Invokedynamic Day!". Retrieved 2008-09-07.
  8. ↑ Lorimer, R.J. (2008-09-01). "Dynamic Invocation Runs on OpenJDK". infoq.com. Retrieved 2008-09-03.
  9. ↑ Nutter, Charles (2008-09-11). "A First Taste of InvokeDynamic". Retrieved 2008-09-13. I managed to successfully wire InvokeDynamic directly into JRuby's dispatch process! Such excitement! The code is already in JRuby's trunk, and will ship with JRuby 1.1.5 (though it obviously will be disabled on JVMs without InvokeDynamic).
  10. ↑ Rose, John (2009-04-22). "progress: indy.patch -> JDK7". Retrieved 2009-04-30. The majority of indy.patch has entered the JDK7 VM at my workgroup's integration repo, today at about 4:00AM PDT:
  11. ↑ Nutter, Charles (2008-09-11). "A First Taste of InvokeDynamic". Retrieved 2008-02-06. The dirty secret of several JVM implementations, Hotspot included, is that there's a separate heap (or a separate generation of the heap) used for special types of data like class definitions, class metadata, and sometimes bytecode or JITted native code. And it couldn't have a scarier name: The Permanent Generation. Except in rare cases, objects loaded into the PermGen are never garbage collected (because they're supposed to be permanent, get it?) and if not used very, very carefully, it will fill up(...)

External links

This article is issued from Wikipedia - version of the 10/7/2016. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.