Wo kann ich filme downloaden?…

Java (Sun 1.6.0_03-b05): 384 sec
Java (JRockit 1.5.0_10): 327 sec

Groovy (Sun 1.6.0_03-b05): 10549 sec
Groovy (JRockit 1.5.0_10): 6375 sec

The ratios:
With Sun 1.6.0_03-b05: 1:27
With JRockit 1.5.0_10: 1:19

Ergo, I prefer JRockit over Sun JVM for groovy development.

Also, if it were a complexity problem, the Java version should suffer equally (albeit with a - large - constant difference to the O() case compared to Groovy)

The code specified in your initial posting incorporates a bubble-sort algorithm which has a performance factor of Q(n^2) — not too good, especially as n (the number of elements to be sorted) increases. If n = 10 million, your code will loop 10 million ^ 2 times, or approximately, 10,000,000,000,000 times.

Your code will perform a lot better if you incorporate a quick-sort algorithm instead, since its performance factor is Q(n log n). If n = 10 million, your code will loop (10 million) (log 10 million), or approximately, 70,000,000 times — a vast improvement!

Bubble sorts have the following structure:

procedure bubbleSort( A : list of sortable items ) defined as:
do
swapped := false
for each i in 0 to length( A ) - 2 do:
if A[ i ] > A[ i + 1 ] then
swap( A[ i ], A[ i + 1 ] )
swapped := true
end if
end for
while swapped
end procedure

Quicksorts, on the other hand, have the following structure:

function quicksort(array)
var list less, equal, greater
if length(array) ? 1
return array
select a pivot value pivot from array
for each x in array
if x pivot then append x to greater
return concatenate(quicksort(less), equal, quicksort(greater))

The other recommendations to this post are all valid, but its the algorithm itself that is your bottleneck. Hope this helps.

Darryl

Data? I can get you all the data you need

I am working with data from the public HapMap project.

Any autosome from here, should do fine. I recommend chromosome 22 as it is the smallest autosome (so less data).

Yoruban 21 - Still one of the smallest, should work directly (change the directory only on the BufferedReader line) with the groovy code (which only processes one chromosome from one population. The Java code does all autosomes of Yorubans and Utahans).

I have put the code here (Along with the Java version).

I would like to thank everybody that offered to help. I have sorted this out in Java and for me it is a done deal.

But we could use this exercise in order to understand and document possible groovy performance pitfalls. So, if you have any suggestions to enhance the code feel free to comment, so that we can help others in not making the mistakes that I have done.

It was not my intention to criticize code quality or anything like that. I dont write groovy idiomatic code all the time myself. I have looked at some groovy code I wrote a few weeks ago. After having written more and more groovy code I could refactor a lot of the old code and eliminate at least half of the LOC count. It was more readable, too.

I would like to provide suggestions on improvement regarding performance, but I dont understand what you are actually trying to do. Could you post the entire code and not just snippets of it? That would be great.

I am using Groovy at work to load a few hundred database entries with lots of hierarchical relationships, traverse those entries to build a specific collections structure, so it can be converted to a specific JSON format for the view layer.

All of this happens in a few ms not more, so I think we can definetly improve your problem.

You can probably also store the iCase[0] and iCase[1] values in variables before the for loop to improve performance comparing to those values.