Decreased array access time without array bounds check in java

Question

Ok. I am miscalculated things of microbenchmarking. Plz dont read if you dont have excess time.

Instead of

double[] my_array=new array[1000000];double blabla=0;
for(int i=0;i<1000000;i++)
{
  my_array[i]=Math.sqrt(i);//init
}

for(int i=0;i<1000000;i++)
{
  blabla+=my_array[i];//array access time is 3.7ms per 1M operation
}

i used

public final static class my_class
{
 public static double element=0;
 my_class(double elementz)
 {
 element=elementz;
 }
}

my_class[] class_z=new my_class[1000000];
for(int i=0;i<1000000;i++)
{
class_z[i]=new my_class(Math.sqrt(i)); //instantiating array elements for later use(random-access)
}

double blabla=0;

for(int i=0;i<1000000;i++)
{
blabla+=class_z[i].element; // array access time 2.7 ms per 1M operations.
}
}

looping overhead is nearly 0.5 ms per 1M looping iterations(used this offset).

Array of classes' element accessing time is %25 lower than a primitive-array's. Question: Do you know any other way to even lower random-access time? intel 2Ghz single core java -eclipse

Peter Lawrey · Accepted Answer · 2012-06-28 15:50:14Z

2

Looking at your code again, I can see that in the first loop you are adding 1m different elements. In the second example, you are adding the same static element 1m times.

A common problem with micro-benchmarks is the order you perform the tests impacts the results.

For example, if you have two loops, the first loops is initially not compiled to native code. However after some time, the whole method will be compiled and the loop will run faster.

Then you run the second loop and find it is either

much faster because it is optimised from the start. (For simple loops)
much slower because it is optimised without any runtime metrics. (For complex loop)

You need to place each loop in a seperate method and run the test alteratively a numebr of times to get reproduceable results.

In your first case, the loop is not optimised until after it has run for a while. In the second case, your loop is likely to already be compiled when it starts.

edited Jun 28, 2012 at 15:50

answered Jun 28, 2012 at 15:35

Peter Lawrey

535k83 gold badges770 silver badges1.2k bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

huseyin tugrul buyukisik Over a year ago

all results are from loop of 0 to 20 . 1st run is warming up. the results are from already warmed positions

Peter Lawrey Over a year ago

I suspect its because element is static so there is only one of them, not one million.

Durandal · Accepted Answer · 2012-06-28 15:52:44Z

1

The difference is easily explained:

The primitive array has a memory footprint of 1M * 8 bytes = 8MB.
The class array has a memory footprint of 1M * 4 bytes = 4MB, all pointing to the same instance (assuming 32bit VM or compressed refs 64bit VM).

Put different objects into your class array and you will see the primitive array perform better. You are comparing oranges to apples at the moment.

answered Jun 28, 2012 at 15:52

Durandal

20.2k4 gold badges39 silver badges71 bronze badges

Comments

Jonathan Dawson · Accepted Answer · 2013-01-25 21:28:45Z

There are several problems with your benchmarks and your assessment above. First, your code doesn't compile as shown. Second, your benchmark times (i.e., a few milliseconds) are far too short to be of any statistical worth with today's high-speed processors. Third, you're comparing apples to oranges (as mentioned above). That is, you're timing two completely different use cases: a single static and a million variables.

I fixed your code and ran it several times on an i7-2620m for 10,000 x 1,000,000 repetitions. All results were within +/- 1%, which is good enough for this discussion. Then, I took the fastest of all of those runs in order to compare their performance.

Above, you claimed that the second use case was "25% lower" than the first. That is wildly inaccurate.

In order to do a "static" versus "variable" performance comparison, I changed the first benchmark to add the 999,999th square-root just like the second one is doing. The difference was only about 4.63% in favor of the second use case.

In order to do an array access performance comparison, I changed the second use case to a "non-static" variable. The difference was about 68.2% in favor of the first use case (primitive array access), meaning that the first way was much faster than the second.

(Feel free to ask me more about micro-benchmarking since I've been doing performance measurement and assessment for over 25 years.)

Collectives™ on Stack Overflow

Decreased array access time without array bounds check in java

3 Answers 3

2 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related