I made a test which perform a simplified in_cksum calculation on a 64KB
packet in a loop. It is done in both C and java (with -server and gcj
(gcc java compiler)

The results where the following:

java -client  11.85    (java 1.5.0_04)
java -server  11.90
gcj         12.26    (gcc 3.3.2 on linux 2.6.3)
C integer     11.01   
C float         7.23

So my advice would be to use C if you need absolute speed, but if you
can accept a little reduction, then java might be ok if you are sticking
with pure native datatypes and operations.

Since the in_cksum operation is entirely an integer operation the C
float version is not really interesting (but I made a mistake to begin
with so I thought it was a valid result)

The code is as follows:

(The C code has to be sligthly changed otherwise the array
initailisation routine would have used float operations instead leading
to the whole program being float operations, with invalid results.)

/***** JAVA *****/

public class Cksum
{
    public static void main(String args[])
        {
            Random rand = new Random();
            int total = 0;
            int count = 65500;
            int data[] = new int[count];

            for(int c=0; c<count; c++) {
                data[c] = rand.nextInt(2000000000);
            }
               
            long startTime = System.currentTimeMillis();
            for(int d=0; d<50000; d++) {
                for(int c=0; c<count; c++) {
                    total += data[c];
                }
            }
            long endTime = System.currentTimeMillis();
           
            System.out.println("Elapsed time (ms): " + (endTime - startTime));
            System.out.println("Total: " + total);
        }
}

/***** C *****/

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>

int main(int argc, char *argv[])
{
    unsigned int total = 0;
    int count = 65500;
    unsigned int data[count];
    unsigned int data2[count];

    for(int c=0; c<count; c++) {
/*         data[c]=1.0+(unsigned int) (2000000000.0*rand()/(RAND_MAX+1.0)); */
        data2[c] = data[c];
    }

    struct timeval start_time;
    struct timeval end_time;
   
    gettimeofday(&start_time, NULL);

    for(int d=0; d<50000; d++) {
        for(int c=0; c<count; c++) {
            total += data[c];
        }
    }
    gettimeofday(&end_time, NULL);

    double t1=(start_time.tv_sec*1000)+(start_time.tv_usec/1000.0);
    double t2=(end_time.tv_sec*1000)+(end_time.tv_usec/1000.0);

    printf("Elapsed time (ms): %.6lf\n", t2-t1);
    printf("Total: %u\n", total);

    for(int c=0; c<100; c++) {
        printf("data2: %u  ", data2[c]);
    }
    printf("\n");
   
    return(0);
}

On Wed, 15 Mar 2006 11:56:55 +0000, Thomas Hawtin
<usenet@tackline.plus.com> wrote, quoted or indirectly quoted someone
who said :

Since Java's array elements are always powers of two, you can get the
address offset from the index by a simple shift.  Some hardware
architectures even give you that shift for free.  In languages where
you can have arrays of objects rather than arrays of references, you
have to do a full multiply. There it becomes really important to
convert the multiply to an add each time through the loop, which chews
up some of your precious registers.

As a side effect of this sort of hoisting you can eliminate the bounds
checks. They are built in to the loop termination check.