I’ve been back from FOSDEM for a couple of weeks. I had a rough
homecoming, though, and after that got lost in catch-up and bug fixing
for a while. Now I’m finally ready to write about what I saw.

The Classpath contingent was lively again this year — some new
faces, but also, unfortunately, some folks didn’t make it. I suppose
we’ll never achieve 100% attendance; that’s ok since I always leave
FOSDEM feeling as though I should have somehow fit in even more
talking than I did.

I stuck to the Classpath room this year. I had really wanted to
get over to see the PiTiVi talk in the Gnome
room, but this overlapped with the Classpath general discussion
session and so I couldn’t leave. Maybe with FC5 I’ll be able to
easily build my own pitivi and demo it to myself.

Free Swing – Roman Kennke

The first talk I have notes for was the Free Swing talk by Roman
Kennke. He gave an overview of the Swing work, contrasting November
2004 (when he started working on it) with today. The Swing hackers
have made huge progress — a year ago it couldn’t really do anything,
and now it can run many actual programs. There are still some
missing things, but today the list looks doable.

For 2006 Roman essentially predicted completeness. His real list
was styled text and HTML, 1.4 compatibility, stability, usability, and
java2d.

CORBA – Audrius Meskauskas

Audrius talked about his work on the GNU Classpath CORBA
implementation. He may have mentioned his work on RMI in passing —
it isn’t in my notes but I remember something about this.

Audrius singlehandedly wrote our CORBA code. Some of the other
free ORBs rely on un-free code — IDL from the OMG which can’t be
modified (incidentally this is apparently one reason we avoided
jacorb). Not us, Audrius reverse engineered it from the spec. Our
implementation also passes more of the official test suite than other
implementations.

JamVM – Robert Lougher

The first thing my notes say is, “send him some congratulations”.
So, congratulations, Rob. JamVM is an excellent program. I use it
every time I work on Classpath and I’m always grateful that it is so
easy to set up and use.

Normally I’d follow this with a wish-list, but as Andrew pointed
out, the time lag between “that’s cool” and “feature X is broken” is
often much too short. So let’s just leave it at congratulations
🙂

Rob’s talk mostly concentrated on JamVM’s implementation approach.
It is what I would describe as a state of the art interpreter. It is
direct threaded, it does stack caching (it has 2 cache registers and
hence 3 versions of each opcode — except on x86 where this is not
very useful), and does dispatch prefetching.

Apparently the stack cache yielded a 20-50% improvement, depending
on the benchmark, especially in combination with the dispatch
prefetching (also called interpreter pipelining or something like
that).

Vmgen – Christian Thalinger, aka twisti

Twisti gave a talk on incorporating a vmgen-based interpreter
into Cacao. vmgen is a cool project from Anton Ertl (read his
interpreter papers, they are quite nice) which automates certain
aspects of stack-based interpreter construction. The basic idea is
that you write your instructions (in a kind of mixture of C and a
forth-like language) and it will generate your interpreter.

The trick is that vmgen knows how to do all the nice interpreter
optimizations for you, so you don’t have to do them by hand. So, it
can do direct threading, stack caching, dispatch prefetching (Twisti
said it doesn’t have this, but I know I first read about it in one of
Ertl’s papers… so I dunno), and both static and dynamic
superinstructions.

A static superinstruction basically turns a common static
instruction sequence into a single instruction. You decide what
superinstructions to make, and then the code that vmgen generates to
handle direct threading will automatically recognize these patterns.
The idea is to cut down on dispatch overhead for common code.

Twisti said that they tried the absurd approach of having 10,000
different superinstructions, but in the end found that just having 100
is enough.

Vmgen also can do dynamic superinstructions. The idea here is
similar to that of SableJIT (or qemu, I think, though I haven’t
looked), where you memcpy the executable instruction
sequences (that GCC generates for your hand-coded VM instructions)
into a big buffer, and then execute that. It is basically a cheap
JIT.

Now we just need to get Ertl to hook vmgen up to LLVM 🙂

Twisti thought it would take about 2 weeks to get a vmgen-based
interpreter up in another free VM. I’d imagine that due to oddities
in our ABI it might be harder to do it for gcj :-(.

Both Rob and Twisti had performance results. Both these
interpreters beat gij pretty handily (and also the Sun and IBM
interpreters), probably due to our ridiculous function call overhead.
I forget which of vmgen or jamvm was fastest; I think they were
reasonably close.

Knopflerfish OSGi – Philippe Laporte

Philippe Laporte gave an impromptu talk about Knopflerfish OSGi.
I didn’t take many notes on this, except that it is BSD licensed right
now.

My Talk

I didn’t take any notes on my own talk. That would have been
weird. My talk was about hacking on Classpath in Eclipse. This went
pretty well — I used the native eclipse on my laptop and didn’t have
any major problems. The talk is basically already encapsulated in a
page
on the Classpath wiki.

Round Table

At the end we went around the room to talk about what we were
doing and the like, led by Mark. I learned some interesting things
here.

Robert Schuster got a job hacking on Classpath, and in particular
Swing. His company does some kind of office application.

Wolfgang Baer talked about printing a bit. He talked about using
iText for printing PDFs.
I didn’t really understand what he was about until I saw his patch
this week that implements an IPP client in Java. I’m constantly
amazed at what Classpath hackers come up with — congratulations
Wolfgang.

Our Plans

I also talked a bit about what we’re doing at Red Hat. Nothing
here is too surprising. We’re currently working in several areas:
JDWP (so you can debug from inside Eclipse), security, the library (in
particular Swing and java2d), and 1.5 stuff (compiler, runtime, and
library).

We tend to do application-driven development, where we look at
the applications that we want to have working, and then finish the
things needed for those.

We’ve got a pretty long list of interesting applications at this
point: jonas (which is driving some of our performance work), the RHDB
tools, Fedora Directory Server (this drove some of the Swing work),
Megamek (found lots of AWT bugs), FOP/Batik (driving Graphics2D work),
gcjwebplugin/netx (driving security work). Of these I would say that
gcjwebplugin is probably the most interesting.

Everybody got a chance to speak during this part, but I didn’t
write down most of it. There was a film crew here, too, and at the
end they asked some questions, which were ok but a bit on the bland
side.