Copying arrays, performance questions

Question

Hello there
The JDK offers several ways to copy arrays so I ran some experiments to try and find out which would be the fastest.
I was measuring the time it takes to copy large arrays of integers. I wrote a program that allocates arrays of various sizes, and copy them several times using different methods. Then I measured the time each method took using the NetBeans profiler and calculated the frequencies.
Here are the results I obtained (click for full size):  http://i.share.pho.to/dc40172a_l.png
(what I call in-place copy is just iterating through the array with a for loop and copying the values one by one)
I generated a graph from those values:  http://i.share.pho.to/049e0f73_l.png
A zoom on the interesting part: http://i.share.pho.to/a9e9a6a4_l.png
According to these results, clone() becomes faster at some point (not sure why). I've re-ran these experiments a few times and it seems to always happen somewhere between 725 and 750.
Now here are my questions:
- Is what I did a valid and reliable way to test performances, or are my results completely irrelevant? And if it's not, what would be a smarter way to do this?
- Will clone be faster than arraycopy past 750 items on any PC or will these results be influences by other factors?
- Is there a way to write a method that would copy the array with optimal performances using clone and arraycopy, such that the cost of using it would be insignificant compared to systematically using one method over the other?
- Any idea why clone() can become faster for bigger arrays? I know arraycopy is a native method, I didn't try to look into what it does exactly but I can't imagine it's doing anything more complicating than copying elements from one location in the memory to another... How can another method be faster than that?
(just reminding I'm copying primitives, not objects)
Thanks!
Message was edited by: xStardust! Added links, mr forum decided to take away my images

Answer 1

yeh, everyone thinks that at some point. it relies,
however, on you being perfect and knowing everything
in advance, which you aren't, and don't (no offence,
the same applies to all of us!). time and time again,
people do this up-front and discover that what they
thought would be a bottleneck, isn't. plus,
the JVM is much smarter at optimizing code than you
think: trust it. the best way to get good performance
out of your code is to write simple, straightforward
good OO code. JVMs are at a point now where they can
optimize java to outperform equivalent C/C++ code
(no, really) but since they're written by human
beings, who have real deadlines and targets, the
optimizations that make it into a release are the
most common ones. just write your application, and
then see how it performs. trust me on this
have a read of
[url=http://java.sun.com/developer/technicalArticles/I
nterviews/goetz_qa.html]this for more info anda chance to see where I plagiarized that post from :-)
Thanks for that link you gave me :)
Was usefull to read.
About time and money of programming, that is not really an issue for me atm since i'm doing this project for a company, but through school (it's like working but not for money).
Of course it should not last entirely long but I got time to figure out alot of things.
For my next project I will try to focus some more on building first, optimizing performance later (if it can be done with a good margin, since it seems the biggest bottlenecks are not the code but things outside the code).
@promethuuzz
The idea was to put collection objects (an object that handles the orm objects initialized) in the request and pass them along to the jsp (this is all done through a customized mvc model).
So I wanted to see if this method was performance heavy so I won't end up writing the entire app and finding out halve of it is very performance heavy :)