Ich hab gerade notgedrungen einen Grundlagentests gemacht, die ergebnisse überraschen mich auch nicht groß, hab sie aber bisher Freud'sch ignoriert :-( ...
Es geht um die Geschwindigkeit von Massen-Datenverarbeitung...
Der ganz unten angehängter Code werkelt ein bisserl auf einem großen double-Array (der typ tut nicht viel zur sache, hab nur einen "großen" genommen)
Er braucht in Millisekunden: (Athlon 1. Generation, 750Mhz)
Server-VM
1.: 1041
2.: 311
HotSpot-VM
1.: 1532
2.: 501
allerdings frisst modulo "%" erstaunlich viel Zeit. (~200 ms)
Der Test zeigt, das der sequentielle Zugriff auf das array (in 2.) erheblich schneller ist, (um den overhead reduziert schätze ich etwa 10 mal) als der wahlfreie Zugriff aus 1. . Bei heutiger Rechnertechnik nicht so verwunderlich, aber doch wichtiger als ich bisher Beachtung ihm geschenkt habe.
Perfektes Beispiel ist sowas wie Pixelweise-Bild-Bearabeitung ..
z.b. ein guter code:
ein extrem viel langsamerer code:
ein riesiges Problem ist das "transponieren" oder "drehen" eines arrays... also sowas wie "bild[x][y] = bild[y][x]" (natürlich mit hilfsspeicher )
So habe ich eine Fast-Fourier-Transform, die mehr als ein DRITTEL mit dem einmaligen Drehen der Daten zu tun hat :-(
aber da lässt sich wohl auch nix machen, oder ?
da würde wohl nur eine Hardware helfen, die den Mist ohne CPU direkt im Speicher "stürzt"
oder gibts da noch bessere methoden (oder klügere Datenstrukturen?)
freu mich über Ideen & mfg
Paul
Es geht um die Geschwindigkeit von Massen-Datenverarbeitung...
Der ganz unten angehängter Code werkelt ein bisserl auf einem großen double-Array (der typ tut nicht viel zur sache, hab nur einen "großen" genommen)
Er braucht in Millisekunden: (Athlon 1. Generation, 750Mhz)
Server-VM
1.: 1041
2.: 311
HotSpot-VM
1.: 1532
2.: 501
allerdings frisst modulo "%" erstaunlich viel Zeit. (~200 ms)
Der Test zeigt, das der sequentielle Zugriff auf das array (in 2.) erheblich schneller ist, (um den overhead reduziert schätze ich etwa 10 mal) als der wahlfreie Zugriff aus 1. . Bei heutiger Rechnertechnik nicht so verwunderlich, aber doch wichtiger als ich bisher Beachtung ihm geschenkt habe.
Perfektes Beispiel ist sowas wie Pixelweise-Bild-Bearabeitung ..
z.b. ein guter code:
Code:
for (x=0; x<w; x++)
for (y=0; y<h; y++)
(mach was mit bild[x][y])
ein extrem viel langsamerer code:
Code:
for (x=0; x<w; x++)
for (y=0; y<h; y++)
(mach was mit bild[y][x])
ein riesiges Problem ist das "transponieren" oder "drehen" eines arrays... also sowas wie "bild[x][y] = bild[y][x]" (natürlich mit hilfsspeicher )
So habe ich eine Fast-Fourier-Transform, die mehr als ein DRITTEL mit dem einmaligen Drehen der Daten zu tun hat :-(
aber da lässt sich wohl auch nix machen, oder ?
da würde wohl nur eine Hardware helfen, die den Mist ohne CPU direkt im Speicher "stürzt"
oder gibts da noch bessere methoden (oder klügere Datenstrukturen?)
freu mich über Ideen & mfg
Paul
Code:
public class Benchmark {
public static void main(String[] args) {
long start,stop;
//init
final int n=5000000;
//double a=1,b=1E10f,c=5;
double[] f=new double[n];
start=System.currentTimeMillis();
//-----------------
for (int i=1; i<n; i++)
f[i]=f[(i*101)%n]+1;
//-----------------
stop=System.currentTimeMillis();
System.out.println("1.: "+(stop-start));
start=System.currentTimeMillis();
//-----------------
for (int i=1; i<n; i++)
f[i]=f[(i-1)%n]+1;
//-----------------
stop=System.currentTimeMillis();
System.out.println("2.: "+(stop-start));
}
}