<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
  <meta content="text/html; charset=ISO-8859-1"
 http-equiv="Content-Type">
</head>
<body bgcolor="#ffffff" text="#000000">
<font face="Helvetica, Arial, sans-serif">Steve-<br>
</font><br>
On 6/30/10 4:37 AM, Steve White wrote:
<blockquote cite="mid:20100630113752.GA26057@cashmere.aip.de"
 type="cite">
  <pre wrap="">Hi,

I have some questions regarding the raw computing speed of the Java VM.  

I've timed some simple numerical (and related) operations written in
various languages, compiled with various compilers, on various platforms. 
They always consist of repeatedly doing some operation to a small array
(small enough that everything fits in an L1 cache) so that the time is
humanly sensible, and then reporting the total time.

Of course, one expects loops in Java to run a bit slower than optimized 
loops in C, as it simply does more: bounds-checking etc.  One surprise is
that in these tests Java's speed is comparable to that of C code optimized
for the platform. 
  </pre>
</blockquote>
On the other hand, a dynamic compiler (such as in HotSpot) can
sometimes do optimizations that a static compiler can't do.&nbsp;&nbsp; Things
like bounds checking can often be optimized away too, so the penalties
of Java may not be severe in contexts where it doesn't need to be.<br>
<blockquote cite="mid:20100630113752.GA26057@cashmere.aip.de"
 type="cite">
  <pre wrap="">
But there are oddities...  Here's what I see:

  On my Intel x86_64-compatible workstation, C loops compiled with gcc
  complete in time very similar to that of Java loops, running on the
  x86_64 VM supplied by my distro.
  </pre>
</blockquote>
<blockquote cite="mid:20100630113752.GA26057@cashmere.aip.de"
 type="cite">
  <pre wrap="">
  However, on IA-32 machines, using the VM of OpenJDK, the Java loops run
  about half the speed as C loops compiled with gcc.
  </pre>
</blockquote>
If you are using the same code generation (see further down), this may
be a combination of the reduced number of registers available
in 32 bit mode, combined with some anomaly of the benchmarks that allow
Java to fit critical fields more fully into registers in the 64 bit
mode.<br>
<blockquote cite="mid:20100630113752.GA26057@cashmere.aip.de"
 type="cite">
  <pre wrap="">
  I tried building the Java VM from source for my IA-32 machine, but saw no
  improvement in performance at all from the distribution VM.

  My notes from several years ago have IBM Java2-13 doing basic operations
  in very little (apparently a small additive constant) more time than 
  optimized C (using gcc, Linux of the time).  On the other hand, I've 
  observed over the years some VM running the same code a factor of ten
  slower than others.
  </pre>
</blockquote>
This is flaw in micro benchmarks:&nbsp; it is easy to find a simple case
which performs comparatively poorly for either Java or C/C++; you just
need to know a bit about how the underlying technology works.<br>
<blockquote cite="mid:20100630113752.GA26057@cashmere.aip.de"
 type="cite">
  <pre wrap="">
** Question 1: Why does the "i386" distro VM perform worse relative to C code
than x86_64 VM?

** Question 2: Why would i386 Java VMs perform so much worse than x86_64? 
Is there a way to get better performance on i386-derived platforms?
(special compiler switches, etc?
  </pre>
</blockquote>
Also, Andrew's suggestion to use "-server" compiler (code generation)
would have an enormous impact if you aren't already doing so.&nbsp; The
"-client" compiler generates code much more quickly, but the code
quality probably won't have the same throughput... so for short-running
applications, it can make a lot of sense.&nbsp; But if you are just
measuring raw throughput, "-server" is very likely to be better.<br>
<br>
A different factors affect the default selection of -server and
-compiler.<br>
<br>
Depending on the benchmark, there are other switches that may benefit
raw performance as well.&nbsp; <br>
<blockquote cite="mid:20100630113752.GA26057@cashmere.aip.de"
 type="cite">
  <pre wrap="">
It would seem that it would be possible to arrange for most obvious
loops in Java to run at speeds very near native speeds.
  </pre>
</blockquote>
For more complex code, Java can often perform better than C++.<br>
<br>
-John<br>
<br>
<blockquote cite="mid:20100630113752.GA26057@cashmere.aip.de"
 type="cite">
  <pre wrap="">
Find some tests attached.  
The code is unfortunately rather crude.  You'll have to adjust the Makefile

Cheers!

  </pre>
</blockquote>
</body>
</html>