I've noticed that Java's performance relative to C is better
on my dual Opteron (CentOS4) than on my dual Athlon (CentOS4,
also). So hardware apparently plays a role.
I noticed that too. I came across this problem in a book of probability
puzzles: you have a drawer with a mix of red and black socks. You pull
out two at random. The probability they will both be red is 1/2. What
is the minimum number of socks that can be in the drawer? How about if
there are an even number of black socks?
After solving this, I wrote a little program to find all numbers of red
and black socks that could be in the drawer, for drawers with up to
999999 red socks.
Afterwards, I decided it would make an amusing little test of languages,
and tried it in C and Java (I had originally done it in Perl). Here's
the Java, turned into a benchmark:
======= JAVA VERSION =======
class Socks
{
public static void main( String[] args )
{
double red, total;
int found = 0;
long start = System.nanoTime();
for ( red = 2; red < 1000000; ++red )
{
double p = 2 * red * (red - 1);
total = 1 + Math.floor(Math.sqrt( p ));
if ( total * (total - 1) == p )
++found;
}
long elapsed = (System.nanoTime() - start)/1000000;
System.out.println( found + " found, elapsed: " + elapsed + " msec" );
}
}
======= C VERSION =======
#include <stdio.h>
#include <math.h>
#include <sys/time.h>
int main( void )
{
struct timeval start, stop;
double red, total;
double elapsed;
int found = 0;
gettimeofday( &start, 0 );
for ( red = 2; red < 1000000; ++red )
{
double p = 2 * red * (red - 1);
total = 1 + floor(sqrt(p));
if ( total * (total - 1) == p )
++found;
}
gettimeofday( &stop, 0 );
elapsed = stop.tv_sec + stop.tv_usec/1000000.0
- start.tv_sec - start.tv_usec/1000000.0;
printf( "%d found, elapsed time: %f msec\n", found, elapsed*1000 );
return 0;
}
On my PowerBook (G4 PPC), Java and C take pretty much the same time. On
my Linux box (2.4 GHz P4), C is twice as fast as Java. Same result on
my iMac (Core Duo)--C is twice as fast.
This is consistent with what I've seen on similar tests. Whenever I've
had some small compute-bound thing I've wanted to do, and tried it on
Java and C, I don't think I've seen Java win on any platform, but it
always seems to be close enough that I would not avoid it if there were
anything that made me otherwise prefer Java for that problem.
Also keep in mind that once you get out of compute-bound programs where
the bottleneck is your code, and start getting into programs where the
bottleneck is in libraries, things can change a lot. Java, for example,
seems to have a pretty good regular expression library, faster than some
I've seen for other languages, so even if Java were going to do my
computation quite a bit slower than C would, that could easily be made
up if I were doing a lot of regular expression matching.
