[Mono-list] JVM performance: JVM as a basis for CLR

Tom tom7ca@yahoo.com
Sun, 22 Jul 2001 03:10:10 -0700 (PDT)

> Just because a specific implementation
> of the CLR is worse off
> than a specific implementation of a JVM doesn't mean
> that Mono couldn't be a better implementation.

I provided one data point, not a comprehensive
and exhaustive study.  I hope other people will
provide other data points and technical arguments.

This particular comparison is doubly important 
because Miguel, I believe, claimed that even an 
unoptimized CLR implementation beats Java.

> Secondly, the comparison also doesn't really mean
> anything. I don't see what you are trying to show
> by this... that Java byte-codes are a better
> intedmediate representation than Microsoft IL for
> writing JITs?

No.  I view the discussion of using the JVM as 
irrelevant to this list.  Mono is a project involving
C# and CIL, and it's clear Mono isn't going to use 
Java/JVM at this point no matter what.  The question
is whether a JVM is a good basis for implementing
a CLR.  Miguel and Microsoft have talked about 
supposed limitations of the JVM instruction set that
they think make this a bad choice.  And there I think
is still time for taking another path.

> You are comparing Beta 2 of a
> product that has _specifically_ been mentioned in
> the past by Microsoft to not have been optimized 
> for speed for purposes of the beta tests against a
> standing JVM.

Microsoft had a mature JIT as part of their JVM, 
and it pretty clearly should have taken only a small 
effort to turn that into the CLR.  I think this claim
is just spin, and I think the CLR is likely to be
as good as it gets.  In fact, Microsoft's claim
that CLR is close to C++ performance contradicts
their claim that they will still be able to do lots
of optimization on it.  In any case, when it comes
to CLR, we have to make do with the choices we have.
Promises of future enhancements are just promises,
often unfulfilled if past experience with language
vendors is any guide.

> Worse yet, you are using a rather abstract test case
> that you don't actually
> run into much in the real world (even in low-level
> stuff like 3D engines).

I don't see anything "worse" about it.  Those happen
to be two characteristics that matter to me.
Microbenchmarks are important for understanding
the characteristics of language implementations and
they have have a long academic and practical history.

If they exist, I would very much be interested in 
seeing other small test cases like this where the CLR 
outperforms Sun's JVM/JIT.

> If you want a better comparison, check out
> http://www.codeproject.com/useritems/sharphsql.asp .

Yes, I'm aware of that, and I was assuming others
were as well.  As I indicated, my results point
in the same direction as those other results.

> At this point I'd normally mention the project I
> started a few months ago to work off of ORP 
> (the one I couldn't get any interest from anyone

Well, great!  I think people should have listened
to you more and participated.  (Maybe you should
have challenged people more with actual benchmarks
and discussions :-)

> but I'm quite soured on it at this point and _I'm_ 
> not even interested in it anymore :-).

Do you have actual performance results on the ORP?
How does it compare to Sun's JVM and the OpenJIT?
Have you actually made useful modifications to
the ORP yet and are those available?

Let me state it clearly again: I am really interested 
in seeing and understanding test cases where a CLR
(theoretically or practically) outperforms a JVM.
I'm asking out of technical interest, to understand
both systems better, not to win an argument.  
But the existence or non-existence of
such cases also should be an important data point
for the choices Mono makes wrt. a CLR implementation.


Do You Yahoo!?
Make international calls for as low as $.04/minute with Yahoo! Messenger