writes about approaches to make distcc work well with gcj. This
is tricky because distcc works by preprocessing your C or C++ source
locally, then shipping the result to another machine for
There seem to be a few plausible approaches to doing this. One
approach is to modify gcj itself. gcj could read your source, analyze
it, find all the dependencies, and then package up a jar file that you
could send remotely. At the remote site you could invoke gcj pointing
at just this jar file. The drawback of this approach is that it
requires invasive and complicated changes to gcj. You might think
there is also a performance problem here, but in practice parsing and
analyzing java source is pretty cheap, code generation is what takes
the most time.
Another approach Anthony puts forward is the idea of using
LD_PRELOAD library to catch all
calls and have the remote compiler ask your machine for the files in
Actually I think this is kind of cool, though it does beg the
question of why you don’t just set up NFS, since after all you’re
serving files. This puts all the nasty potential security problems
into a known framework.
Anyway, I think that his approach will work ok. It would be
interesting to see how well it performs. It looks like his approach
caches the files it opens, meaning that for a large compilation the
number of files shipped over the network will dwindle. Another
benefit of this approach is that the debugging information will always
turn out right, since gcc will always request things by their real
One remaining approach is to just write a wrapper for gcj that
ships everything mentioned on the class path to the remote server. If
the class path includes a directory, just ship all the java files.
You could use rsync for this to avoid shipping files more than once.