Hi all,
As a continue to some responses from a previous thread (Some code optimization and thanks again, everybody, despite the criticism - no hard feelings :)) I decided to try rewrite a small piece of prel code in java, in order to get some feeling about the performance differences.
I wrote the java equivalent real quickly, and it's not so "beautiful", but I think it works OK.
The results:
perl: 20.8 seconds
java: 3.9 seconds
Here is the perl code:
use strict;
use warnings;
use List::Util qw(max min);
use Time::HiRes qw(time);
# this builds a structure that is usually retrieved from disk.
# in this example we will use this structure again and again,
# but in the real program we obviously retrieve a fresh structure
# at each iteration
my $simulation_h = {};
for ( 1 .. 70000 ) {
my $random_start = int( rand(5235641) );
my $random_length = int( rand(40000) );
push @{ $simulation_h->{$random_start} }, $random_length;
}
my $zone_o = {
_chromosome_length => 5235641,
_legal_range => [ { FROM => 100000, TO => 200000 } ]
};
my $start_time = time;
scenario();
print "total loop time: " . ( time - $start_time ) . " seconds\n";
my $temp_gene_to_legal_range;
my $gene_to;
sub scenario {
for ( my $i = 0 ; $i < 50 ; $i++ ) {
print "i=$i time=" . ( time - $start_time ) . " seconds\n";
# originally there was a retreive of $simulation_h from disk h
+ere
# iterate genes
foreach my $gene_from ( keys %{$simulation_h} ) {
foreach my $gene_length ( @{ $simulation_h->{$gene_from} }
+ ) {
### inlining gene_to_legal_range
$gene_to =
( ( $gene_from + $gene_length - 1 )
% ( $zone_o->{_chromosome_length} ) ) + 1;
if ( $gene_to < $gene_from ) {
# split
# low range first
$temp_gene_to_legal_range = [
{ FROM => 0, TO => $gene_to },
{
FROM => $gene_from,
TO => $zone_o->{_chromosome_length}
}
];
}
else {
# single
$temp_gene_to_legal_range =
[ { FROM => $gene_from, TO => $gene_to } ];
}
}
}
}
}
And here is the java code:
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
public class InLine {
public static void main(String[] args) {
int count = 0;
Random rand = new Random();
Map<Integer, List<Integer>> genes = new HashMap<Integer, List<
+Integer>>();
for (int i = 0; i < 70000; i++) {
Integer randStart = rand.nextInt(5235641);
Integer randLength = rand.nextInt(40000);
if (!genes.containsKey(randStart)) {
List<Integer> list = new ArrayList<Integer>();
genes.put(randStart, list);
}
genes.get(randStart).add(randLength);
}
int chromosomeLength = 5235641;
SimpleRange simpleRange = new SimpleRange(100000, 200000);
Set<SimpleRange> setSimpleRanges = new HashSet<SimpleRange>();
setSimpleRanges.add(simpleRange);
long startTimeMillis = System.currentTimeMillis();
for (int i = 0; i < 50; i++) {
System.out
.println("Iter = "
+ i
+ " Time from start: "
+ ((double) (System.currentTimeMillis() -
+startTimeMillis) / 1000));
for (int geneFrom : genes.keySet()) {
for (int geneLength : genes.get(geneFrom)) {
int geneTo = (geneFrom + geneLength - 1) % chromos
+omeLength
+ 1;
if (geneTo < geneFrom) {
// split
// low range first
SimpleRange lowSimpleRange = new SimpleRange(0
+, geneTo);
SimpleRange highSimpleRange = new SimpleRange(
+geneFrom,
chromosomeLength);
Set<SimpleRange> setSimpleRanges1 = new HashSe
+t<SimpleRange>();
setSimpleRanges1.add(lowSimpleRange);
setSimpleRanges1.add(highSimpleRange);
count++;
} else {
// single
SimpleRange simpleRange1 = new SimpleRange(gen
+eFrom,
geneTo);
Set<SimpleRange> setSimpleRanges1 = new HashSe
+t<SimpleRange>();
setSimpleRanges1.add(simpleRange1);
count++;
}
}
}
}
System.out
.println("Time from start: "
+ ((double) (System.currentTimeMillis() - star
+tTimeMillis) / 1000)
+ " count=" + count);
}
}
class LegalRange {
Set<SimpleRange> set;
public LegalRange(Set<SimpleRange> set) {
this.set = set;
}
}
class SimpleRange {
int from;
int to;
public SimpleRange(int from, int to) {
this.from = from;
this.to = to;
}
}
Am I missing anything? Is my perl code highly inefficient in some mysterious way?
I was quite surprised by the difference.
