Geek in progress

The past few days, I’ve attended VEE 2010. I registered prior to receiving the definite decision on the paper we submitted — it was rejected (with weak reviews IMHO, but still rejected is rejected and nothing you can do about it). So I did not really have an idea on what the program would be about. Turns out, it’s petty OK, even though most of it is besides my general area of interest/work.

Nonetheless, the opening keynote talk was pretty interesting, if only for the take Peter Chen has on education and teaching systems. The bottom line is: challenge students with something difficult and give them the tools and help to get there. His first year students are allowed to pick anything to implement as a system, provided it is fun and not completely impossible. However, it seems to me that the requirements in teaching assistants is pretty high. Peter said that undergrad students are assisting, and that is one path we cannot take in Belgium. Students must study, not assist. I do like the bottom up approach, but I wonder how feasible it would be, given that our students have trouble grokking pushl 4(%eax). But still, given a small Altera board, a simple instruction set ABI, and simple rules, they managed to do nifty stuff. On example was a Guitar Hero clone, but using a real instrument, where the system recognised the note that was played. Another example included a game, driven by voice (tone, pitch, length) to fly a chopper through a 2D cave. The conclusion: an enlightening talk, showing that maybe we underestimate our students too often.

The first session was on debugging, and the most interesting talk was on a nifty VMM based replay system. The major improvement over what I recall from the work Frank Cornelis did at ELIS, was that these guys reduce the amount of data to retain, while still following all of the execution. Furthermore, they show that a replay system is but a state machine, and such a state machine can be built at user level, taking the (transformed) VMM recorded data and shoving it to the replayed process. Basically they allow replaying on any machine, and they are completely OS/app agnostic. Hence sending bug reports should be transparent enough to allow users to have the recording on at all times.

The keynote of the second day revolved around Singularity. Yes, the stuff from Microsoft. Now, everybody who knows me, knows that I’m no fan of that particular company, but I do dig their research department. This was followed by a talk on XIR trying to decouple the JIT compiler from the runtime system, or at least to define the interface in a better way. The second paper presented this morning was VMKit, which was pretty cool. Using standard software components (LLVM, MMtk, and libpthread), the authors define an interface between these components and to the higher level language. They showed you can easily implement a Java and a .NET VM on top to VMKit, with reasonable performance. J3 is around 2x slower than Jikes RVM, whereas N3 is comparable to Mono. I think this can be a very handy toolkit to move our COLE research to.

Google also had an invited talk on their new gadget to run native code inline in the browser. There are some restrictions, such as not all assembly instructions are allowed, which makes sense, but it also limits what applications you can run natively. One of the examples was Quake, which made me think the tool was pretty cool. Yet, we already have a native Quake Arena type of plugin. Second, at this point it is unclear what other application types you would want to run, but I can see that with ChromeOS being released onto the (unsuspecting?) world, having something that allows classical apps to be transported to the browser OS, is a nifty thing indeed.

In the afternoon, there were some more talk on VMMs, the first of which presented NEON , which uses the VMM and QEMU to see where tainted data is going. It was pretty cool that they can follow copies of the data, even as they are copied using copy ’n paste like actions by the user, to prohibit sensitive material to be send outside of the trusted zone. One remark was that typically, people see that everything gets a taint after a while, but Qing Zhang claimed this was not the case in their experiments, which, admittedly has not been running for months on end. I thought it was a pretty cool thing to do, and it shows that perhaps the notion I have of measuring QoS VMM side is not such a bad idea. Or at least not completely unfeasible.

The last talk on Thursday which kicked major ass was on AASH, which is an Asymmetric Aware Scheduler for Hypervisors. The premise was that the hypervisor (Xen, in particular) is not aware of the possibility that the machine potentially has a heterogeneous array of CPUs or cores. For example, a new system might feature a Corei7 and several Atoms. The former being used for CPU bound workloads, the latter being used for memory bound workloads. The authors extended the Xen credit scheduler with a second type of credits, i.e., fast credits, to be split among so-called fast VCPUs, whereas the original credits (the slow credits) are then shared among the slow VCPUs. When a fast VCPU runs out of fast credits for the current accounting time, they are moved to a slow CPU. I think it’s a pretty brilliant and simple idea. The results are indicative of the fact that this works well in practice, at least for SPEC CPU 2000 benchmarks (crafty being CPU bound, mcf and equake classified as memory bound). The only thing I found to be subpar was the use of execution time for measuring how well these benchmarks were doing under the dual credit scheduler. In a multiprogram system, per-program execution time is not the right metric. Instead, one should use STP and ANTT (Eyerman and Eeckhout, MICRO 2008) for execution time based workloads or TNT and ANRT (Georges and Eeckhout, HPCVirt 2010) for throughput based workloads.

In the Friday Java session, the allocation site tracking was the most impressive paper, in my opinion. Again, a fairly simple idea, but it does seem to help against memory leaks. Up to now, Mike Bond et al. have proposed a number of approached to deal with semantic memory leaks, but this paper seems to provide the means of locating them, without too much overhead. The key idea is that one replaces some field, or part thereof, in the object header to identify the allocation site where the object was allocated. Upon GC, as each live object is walked, statistics can be assembled and the allocation sites with the most surviving objects may indicate leaks, provided the heap usage keeps growing after each global GC. The authors define two options, using the hash code header field, or it this is not present, the class pointer in the object header. They adequately deal with all potential problems, such as the hash code field colliding (they introduce a random value and shrink the allocation site ID size for hot sites).

The last few talks on binary translation we, put bluntly, hard to follow. So that about wrapped it up for VEE. I had a number of interesting chats with people from VMware, Oracle (formerly BEA, and it seems they still prefer that), and the ubiquitous Steve Blackburn. If all goes well, I’ll be back next year.