Beside DLS and VMIL, there was also a workshop on Actor systems. However, I did not make it to this one. Cherry picking between DLS and VMIL was already hard enough and worked out only partially.

The two DLS keynotes were certainly highlights of the whole SPLASH conference. Gilad’s talk, on Dart was not just interesting but quite entertaining; especially their take on the optional type system looks useful. I like the reasoning behind their approach a lot. Who needs sound type systems anyway? Well, then again, I had a few bugs were a complete type system could have notified me earlier to make me aware that I am doing something stupid. So, I wonder whether it would be hard to have another optional type system in addition, which could be enabled on demand for certain modules to check a more strict set of constraints?

The second DLS keynote was David’s presentation with the title: “Everything You Know (About Parallel Programming) is Wrong!: A Wild Screed About the Future”. The main conclusion is certainly that Romeo would not have died when there would have been synchronization to avoid the race condition. What a nerdy example

In the end, the parallel revolution will need to find the balance between performance and correctness, since correctness is always bought by introducing delays and thus hampers performance. Another point he made more implicitly is that programming these systems becomes not only harder because of the parallel aspect, but also because of the ever-growing complexity of the underlying hardware. We just do not know anymore what is going on and why the performance is not as expected.

The VMIL workshop started with Eliot’s presentation. But, well, if you know how Eliot presents his work on the Cog VM then you know, that it is likely that people not acquainted with the details of Smalltalk VMs have a very hard time to follow. His paper made the message a bit clearer, I think. His main point was the VM integration of the Bochs processor emulator for debugging.

After the first break, Lars talked a bit too much about Dart as a language, and the VM details were rather scarce. They said that they are going for simplicity, and the one aspect that I remember was that they do not have any static initialization to avoid ‘spontaneous’ executions. And well, their Smalltalk and Java history certainly shows between the lines.

The talk titled “Virtual machines should be invisible” was essentially about how to build a VM that reuses the standard systems ABI to integrate better with the surrounding system. They use the DWARF debugging format and dynamic linking techniques to reach that goal. Interesting but not platform-independent and I do not really see why that would be desirable or necessary for what I consider a VM.

I unfortunately missed the talk on “A Microbenchmark Case Study and Lessons Learned”. From the comments made later in the workshop, it seemed to have been an interesting and very relevant talk.

The talk titled “Intermediate Language Extensions for Parallelism” was interesting, but I found that this IL is rather language dependent and is only applicable for a X10 or Habanero-ish language. Sure, the Cilk-style seems to be useful for a number of parallel problems, but it is not the only paradigm out there, so I wonder how that IL would look like if it would be designed for a multi-language VM.

The last talk of the workshop was mine: Which Problems Does a Multi-Language Virtual Machine Need to Solve in the Multicore/Manycore Era? So, if you have any answers or thoughts on that topic, please leave me a note.

For an impression on the location itself, I will just cite and refer to what Nick wrote on the JOT blog:
“Reno airport was like a gateway into hell, slot machines everywhere [...] The conference venue is almost comically grim. The main floor is a sea of slot machines and haggard looking people.”
So, it was definitely not the most exciting place ever, and I was already worried that my colleagues start to shoot at those zombies

Anyway, from the content point of view, it was actually a nice conference for me.

On Sunday the Virtual Machine Intermediate Languages workshop took place. As last year, that is the most relevant workshop with respect to VMs I came across so far. This year, especially the invited talks were very interesting.

A JVM Does What????

Cliff Click started with reporting on his perception of JVMs and the illusions they provide to the developers. My take away from his talk are the following points.

First, garbage collection is still the major issue, and people are willing to pay for better performance here. He kind of implied that JIT compilers are nice to have, but not as high on the list of priorities for his typical customers.

Second, he wants people to explore alternative concurrency models on top of the VM. From his perspective, the JVM is a great platform and things like locks are cheap. He agrees that things like Erlang-like Actors need deeper hocks into the Java Memory Model and possibly the JIT compiler, but in general I understood that he would rather prefer something on top instead of another thing integrated into the VM. Well, lets see how my ideas work out.

Related to my ideas we had a small discussion afterwards with David. I was surprised that Azul uses a Uniform Memory Access model for its systems but apparently the problem is that current business applications exhibit random access patterns all over the heap. Thus, if you have a system with 16 chips and 16 memory controller, 15/16 of the access are going remote anyway. That is why the optimize for that case instead of optimizing local performance. Interesting, but perhaps just the consequence of not having appropriate languages which take locality into account in the first place.

SPUR: A Trace-Based JIT Compiler for CIL

Nikolai Tillmann reported on the SPUR project at Microsoft Research. He gave a introduction to tracing-based just-in-time compilation and also present some benchmarks. The interesting part about SPUR is that they actually JIT .NET but experiment mainly with JavaScript.

For me the most interesting aspect of his talk was the future work section were he mentioned a few attempts on parallelizing code by the tracing JIT. Their ideas mainly focus on vectorization which is kind of not so exciting, hope they will also look into speculative execution, even so Nikolai asks for more hardware support for such an idea.

A Systematic Mapping Study on High-level Language Virtual Machines

The first research paper I am going to mention here was meta research on VM research.

The authors surveyed the body of literature on VMs to find out what people are doing research on. Well, the scope was a bit to narrow to actually cover all interesting papers, but it is a very nice first step. David was a bit disappointed that his Self and other Smalltalk papers were not covered and that the literature that was identified as being relevant only started in the 90′ies or so. Well, the authors were already aware of those limitations, but beside this definitely constructive criticism, the audience also came up with proposals to get us as the community involved. There is serious interest in such research and people would be happy with helping classifying (and certainly promoting their own research) if that could happen on a wiki or so…

The Architecture of DecentVM – Towards a Decentralized Virtual Machine for Many-Core Computing

How’s the Parallel Computing Revolution Going? Towards Parallel Scalable Virtual Machine Services

Kathryn McKinley reported on experiments her students did to compare the speed and power consumption of CPUs over the last few years. Turns out, the power consumption seems to rise faster than the performance, especially since the benchmarks do not scale perfectly for multicore applications. However, there is quite a bit of progress with respect to saving energy instead of increasing performance with Intel’s Atom and related architectures.

Interesting was her proposal to parallelize the VM in itself. Something Theo always asks for, too. However, Cliff Click basically said that HotSpot is already at that point for most parts. So, at least from his perspective, that is not a field where major breakthroughs will come from…

Monday, the second day of workshops was less interesting. I started in the day with giving my presentation at the Doctoral Symposium. Did not get more than meta-feedback, unfortunately. I guess, it was just to early for that. What I have is an idea (perhaps with to many open design options) and a plan to validate it. But it was obviously still too fluffy… On the other hand, that meant I was missing great workshops like for instance Evaluate 2010 and the Dynamic Languages Symposium *sigh*

Abstract

Today’s major high-level language virtual machines (VMs) are becoming successful in being multi-language execution platforms, hosting a wide range of languages. With the transition from few-core to many-core processors, we argue that VMs will also have to abstract from concrete concurrency models at the hardware level, to be able to support a wide range of abstract concurrency models on a language level. To overcome the lack of sufficient abstractions for concurrency concepts in VMs, we proposed earlier to extend VM intermediate languages by special concurrency constructs[PLACES09].

As a first step towards this goal, we try to fill a gap in the current literature and survey the intermediate language design of VMs. Our goal is to identify currently used techniques and principles as well as to gain an overview over the available concurrency related features in intermediate languages.

Another aspect of interest is the influence of the particular target language, for which the VM is originally intended, on the intermediate language.

• Paper: PDF
  ©ACM, 2009. This is the author’s version of the work. It is posted here by permission of ACM for your personal use. Not for redistribution. The definitive version was published in VMIL’09, October 25, 2009. http://doi.acm.org/10.1145/1711506.1711509
• BibTex: BibSonomy

Slides of the Talk at VMIL09/OOPSLA