Register VMs : Rise of the machines

I am currently designing and implementing small language with in-built concurrency for experimental/learning purpose. I decided to go with virtual machine approach, but when we implement a virtual machine, we hit by a long-running question in the design of virtual machines, whether to go with stack architecture or with register architecture?

Many of virtual machines are implemented with stack architecture.

Stack based VMs:

• The Java Virtual Machine.
• .NET CLR
• Perl 5 virtual machine.
• SQLite Virtual Database Engine.

There is lot of interest in implementing VM based on register architecture too and practical register based VMs are started emerging.

Register based VMs:

• Parrot VM - http://en.wikipedia.org/wiki/Parrot_virtual_machine
• Android Dalvik VM - http://en.wikipedia.org/wiki/Dalvik_virtual_machine
• Webkit Javascript VM - http://webkit.org/blog/189/announcing-squirrelfish/

I decided to go with register based VM, thought of below two options and decided to go with first.

1) Implementing my register based VM in C

2) Implementing my register based VM in Java (Hey, java is improving and sun is adding multi language support and it is open!!!, so why not?) - In this case my VM itself interpreted on stack based JVM!!!

Magic of Multilanguage Environment

We need to create methods at runtime (say, based on some user input we need to construct an behavior in the form of methods) and associate/execute that methods in the context of particular existing object instance. How could we achieve this in Java?

1) Use features of mlvm. Currently it is in prototype stage. So we may have to wait for some time before being available as part of standard distribution.

2) We could use any of byte code engineering libraries and include a method in the class at runtime. But we are trying to include a method for a particular object instance of the class. Not in the class itself.

Hey, Javacript/Ruby very much allow adding new methods to a particular instance and good news is that we have matured Javascript (Rhino) and Ruby (JRuby) implementations in Java. You may be aware that Rhino javascript implementation is included as part of standard java 6 distribution. With the help of Rhino engine, we could take advantage of power of javascript and implement our scenario.

Include JDK_6_HOME/bin in your path.
Type jrunscript in command prompt.

var fr = new javax.swing.JFrame()
fr.title = "My Title"
fr.setSize(200, 200)
fr.show()

var fn_title = function(title_text) {this.title = title_text}
fn_title.call(fr, "My New Title")

"fn_title" is the method, that we have associated with "JFrame" instance "fr"

PS: Rhino engine is written in Java. How easy to simulate above behavior with our own java classes and byte code engineering? Look at these slides for answer.

Jax India 2008 - Open JDK Multi Language Virtual Machine (MLVM) / The Da Vinci Machine

Yesterday, I spoke at Jax India 2008. My session was on "The Da Vinci Machine - Multi Language Environment for Java Virtual Machine". There were around 70 to 90 participants.
My session went fine with number of good questions from participants. Started my talk with "why we need other languages support on JVM" then pitched into "Introduction to porting new languages on JVM" and ended my talk with discussion on various "MLVM features (Light-weight byte code loading, light weight method objects, Dynamic Invocation, Symbolic freedom, Continuations and Tail recursion)". Click here for presentation slides.

Interesting open source license

When we build project for clients based on number of open source libraries, we typically look into licensing policy of each open source library and analyze how well they fit with client policies. While analyzing one such policy of open source library, I was asked by my colleague what was the interesting licensing policy you have come across?, without second thought i replied back, policy of SQLite. Here is extracted license text from SQLite

“ The author disclaims copyright to this source code. In place of a legal notice, here is a blessing:

May you do good and not evil.
May you find forgiveness for yourself and forgive others.
May you share freely, never taking more than you give. “

Isn't it interesting?.

Customizable Closure with OpenJDK MLVM and javac

The customizable closure code listed below, take advantage of following,

1. Closure data types are converted to inner classes at compile time.
2. AnnonymousClassLoader in MLVM, allows us to load multiple definitions of same class in the same instance of the class loader at run time.

Code:

import java.dyn.AnonymousClassLoader;

public class CustomizableClosure {

static private {String => void} welcomeClosure  =
{ String name => System.out.println(name + ",  " + shortWelcome);};

   static String shortWelcome = " Welcome to closure...";
   static String detailedWelcome =
" Welcome to MLVM closure customization..Experience the power of AnonymousClassLoader...";

   public static void main(String[] args) throws Exception {
       CustomizableClosure.testSimpleClosure();
       CustomizableClosure.testCustomizableClosure();
   }

   static void testSimpleClosure() {
       System.out.println("=================");
       System.out.println("Before customization..");
       welcomeClosure.invoke("Dear bob");
       System.out.println("=================");
   }

   static void testCustomizableClosure() throws Exception {
       AnonymousClassLoader acl = new AnonymousClassLoader();

       acl.setClassFile(welcomeClosure.getClass());
       Class hostClass = CustomizableClosure.class;

       Class acls = welcomeClosure.getClass();
       acl.putSymbolPatch("shortWelcome", "detailedWelcome");
       acls = acl.loadClass();
 
       {String => void} obj = ({String => void}) acls.newInstance();
       System.out.println("================");
       System.out.println("After customization..");
       obj.invoke("Dear bob");
       System.out.println("================");
   }
}

Output:

=================
Before customization..
Dear bob, Welcome to closure...
=================
================
After customization..
Dear bob, Welcome to MLVM closure customization..Experience the power of AnonymousClassLoader...
=================

OK, what's going on?

1. {String => void} welcomeClosure = { String name => System.out.println(name + ", " + shortWelcome);} this closure snippet is converted to inner class at compile time.
2. In method "testSimpleClosure", we are executing closure code as is.
3. In method "testCustomizableClosure", we take closure (compiled inner class) as base template, customize it (by changing welcome text) at run time and execute it.

Step by step instructions on how to build and run Customizable Closure code.

1. Build OpenJDK and Hotspot.
2. Apply MLVM patch and rebuild Hotspot.
3. Download javac for closures from javac.info
4. Prepend MLVM AnonymousClassLoader.class and javac.jar to bootclasspath of java and javac. In my local machine, i used following commands for compilation and execution.

• javac -J-Xbootclasspath/p:/share/software/OpenJDK/closures-2008-02-12/lib/javac.jar:/share/software/OpenJDK/mlvm/bootcp -source 7 -d classes/ CustomizableClosure.java
• java -Xbootclasspath/p:/share/software/OpenJDK/closures-2008-02-12/lib/javac.jar:/share/software/OpenJDK/mlvm/bootcp -cp classes CustomizableClosure

AnonymousClassLoader in OpenJDK Mlti-Language VM (MLVM)

When we implement JIT interpreter for dynamic languages on JVM, we typically deal with set of data (Environment) and Operations (Methods, Lambda etc).

Design and loading of class definition for data and operations on JVM, has following challenges (pains),

a) We can't define a light weight / anonymous methods in JVM on the fly.

Method definition must live in a class. (Relationship between class that defines method and data could be composition or inheritance).

b) We can't load multiple class definitions of same class / overwrite previously loaded class definition with new one, in the same class loader.

Class loader keeps track of all loaded class in its System Dictionary. When we try to reload class definition (even though class definition is changed after first load), class loader checks for any entry in System dictionary for a given class name. If so, it will return class definition of system dictionary entry.

To circumvent above issue, we instantiate (custom) new class loader every time when class definition changes.

c) Garbage collection issue

Class loader is another Java class in JDK. When a class (Let's call host class) instantiates our custom class loader; say CL1, class loader of host class (could be system class loader or ext class loader or another custom class loader) can reach CL1 class loader. Make sure custom class loaders like CL1 are eligible for GC (there by all classes loaded by that class loader) when they are no longer useful.

OpenJDK Mlti-Language VM, introduces java.dyn.AnonymousClassLoader that alleviates above pain points,

1) No System Dictionary in AnonymousClassLoader and AnonymousClassLoader is independent of existing class loaders in JDK. (Refer AnonymousClassLoader.java)

2) We can load multiple definition of same class using same instance of AnonymousClassLoader and it is responsibility of the user to choose preferred class definition among loaded class definitions to create instance. (Refer testAPI method of DVMTest.java)

3) Classes defined by AnonymousClassLoader are not reachable by class loader of host class. Making not-in-use class definitions available for GC is simple.

Above points are not theory, we have tested and working prototype ready. If you want to try yourself, refer my previous post on building MLVM.

QR code for building MLVM :

Building OpenJDK Multi-Language VM aka The Da Vinci Machine

Life is more exciting with multi-language support on JVM. Recently john rose @ sun, created patch for loading anonymous classes in the VM ( read carefully, we are not talking about anonymous classes in JDK, we are talking about loading anonymous classes at VM level ). JVM wouldn't not allow someone to change structure of a class once it loaded. Though this security feature brings-in stability to JVM, dynamic language implementors for JVM are forced to write lots of boiler plate code to simulate dynamism on top of JVM (Ex: In Ruby, methods can be added, removed, modified at runtime, even class structure can be changed @ runtime too). The recent patch added by john for OpenJDK allows us to load an arbitrary class from a block of bytecodes and associate the new class with a pre-existing host class, inheriting its access, linkage, and permission characteristics. Very interesting thing is, a block of bytecodes can be template class file and this template class can be customized at runtime using various constant pool patching methods in java.dyn.AnonymousClassLoader, just before loaded by AnonymousClassLoader class loader. This patch not only alienate pain of other language implementers to a greater extent but accentuate complete JDK and Hotspot with new way of loading and linking anonymous classes in JVM, thereby opening up developers mind in yet another innovative direction. Read john's blog on anonymous classes in the vm for more details on this feature. Pretty exciting ha?, Wanna try it out yourself?. Here is the step by step instruction for applying multi-language path to Open JDK Hotspot VM and building mlvm aka The Davinci VM.

If you haven't successfully built Open JDK and Hotspot VM, go through simonis blog on building Open JDK and hotspot on linux. Once you successfully built OpenJDK and Hotspot, follow
below instructions for building and running mlvm,

• Download mlvm paths and related files

http://homepage.mac.com/rose00/work/webrev/6652736/wkk.patch
http://homepage.mac.com/rose00/work/webrev/6653858/anonk.patch
http://homepage.mac.com/rose00/work/webrev/6653858/DVMTest.zip

• Applying patchs

cd /jdk7/hotspot
patch -p1 --backup-if-mismatch < /home/tselvan/mlvm/patches/wkk.patch
patch -p1 --backup-if-mismatch < /home/tselvan/mlvm/patches/anonk.patch

• Build OpenJDK Hotspot VM
  

LANG=C \
ALT_BOOTDIR=/share/software/jdk1.6.0_04/ \ HOTSPOT_BUILD_JOBS=1 \ ALT_OUTPUTDIR=../../build/hotspot_debug \ make jvmg 2>&1 | tee ../../build/hotspot_debug.log

• Give necessary permissions to libjvm.so under linux,

chcon -t texrel_shlib_t /share/software/OpenJDK/jdk7/build/openjdk_full_debug/lib/i386/*.so
chcon -t texrel_shlib_t /share/software/OpenJDK/jdk7/build/openjdk_full_debug/j2sdk-image/jre/lib/i386/*.so

• set PATH and JAVA_HOME

export PATH=/share/software/OpenJDK/jdk7/build/openjdk_full_debug/bin:$PATH
export JAVA_HOME=/share/software/OpenJDK/jdk7/build/openjdk_full_debug

• Running sample mlvm program
  

Unzip DVMTest.zip, ( i have locally unziped to /share/software/OpenJDK/mlvm)
Run Make.sh
java -esa -ea -Xbootclasspath/p:/share/software/OpenJDK/mlvm/bootcp -cp /share/software/OpenJDK/mlvm DVMTest

If you like to have discussion on mlvm, leave your comments or lets catch up during DevCamp. Watch this space for more experiment with mlvm in coming weeks.