Question

I’m attempting to test some benchmarking tools by running them against a simple program which increments a variable as many times as possible for 1000 milliseconds.

How many incrementations of a single 64 bit number should I expect to be able to perform on an intel i7 chip on the JDK for Mac OS X ?

My current methodology is :

• start thread (t2) that continually increments “i” in an infinite loop (for(;;;)).
• let the main thread (call it t1) sleep for 1000 milliseconds.
• have t1 interrupt (or stop, since this deprecated method works on Apple’s JDK 6) t2.

Currently, I am reproducibly getting about 2E8 incrementations (this is tabulated below: the value shown is the value that is printed when the incrementing thread is interrupted after a 1000 millisecond sleep() in the calling thread).

217057470

223302277

212337757

215177075

214785738

213849329

215645992

215651712

215363726

216135710

How can I know wether this benchmark is reasonable or not, i.e., what is the theoretical fastest speed at which an i7 chip should be able to increment a single 64-bit digit? This code is running in the JVM and is below:

package net.rudolfcode.jvm;

/**
 * How many instructions can the JVM exeucte in a second?
 * @author jayunit100
 */
public class Example3B {
public static void main(String[] args){
    for(int i =0 ; i < 10 ; i++){
        Thread addThread = createThread();
        runForASecond(addThread,1000);
    }
}


private static Thread createThread() {
    Thread addThread = new Thread(){
        Long i =0L;
        public void run() {
            boolean t=true;
            for (;;) {
                try {
                    i++;
                } 
                catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        @Override
        public void interrupt() {
            System.out.println(i);
            super.interrupt();
        }

    };
    return addThread;
}


private static void runForASecond(Thread addThread, int milli) {
    addThread.start();
    try{
        Thread.sleep(milli);
    }
    catch(Exception e){

    }
    addThread.interrupt();
    //stop() works on some JVMs...
    addThread.stop();
}

}

Answer 1

Theoretically, making some assumptions which are probably not valid:

• Assume that a number can be incremented in 1 instruction (probably not, because you’re running in a JVM and not natively)
• Assume that a 2.5 GHz processor can execute 2,500,000,000 instructions per second (but in reality, it’s more complicated than that)

Then you could say that 2,500,000,000 increments in 1 second is a “reasonable” upper bound based on the simplest possible back-of-the-envelope estimation.

How far off is that from your measurement?

• 2,500,000,000 is O(1,000,000,000)
• 2E8 is O(100,000,000)

So we’re only off by 1 order of magnitude. Given the wildly unfounded assumptions – sounds reasonable to me.