Double schneller als Float?

[vimar]

public class Speedtest {

    /**
     * @param args the command line arguments
     */
    static double vorher;
    static double nachher;
    
    static double d1,d2,d3,d4;
   static float f1,f2,f3,f4;
    static double dErg;
    static float fErg;
    
    public static void main(String[] args) {
        // TODO code application logic here
        
        f1 = (float) Math.sqrt(3);
        f2 = (float) Math.sqrt(5);
        f3 = (float) Math.sqrt(7);
        f4 = (float) Math.sqrt(10);
        
        
        d1 = Math.sqrt(3);
        d2 = Math.sqrt(5);
        d3 = Math.sqrt(7);
        d4 = Math.sqrt(10);
        
       // float rechnung       
        vorher = System.currentTimeMillis();
        fErg = (f2-f1)*(f2-f1) + (f4-f3)* (f4-f3);
         nachher = System.currentTimeMillis()- vorher;
         
         System.out.println("Float Time: " + fErg);
        
        
     // double rechnung  
        vorher = System.currentTimeMillis();
        dErg = (d2-d1)*(d2-d1) + (d4-d3)* (d4-d3);
        nachher = System.currentTimeMillis()- vorher;
        
        System.out.println("Double Time: "+ nachher);
        
        
    }
}

Output:

run:
Float Time: 0.520833
Double Time: 0.0
BUILD SUCCESSFUL (total time: 0 seconds)


float ist 32bit, double 64bit und float ist langsamer? wieso?

 

[maki]

Micro Benchsmarks sind nutzlos

Was passiert, wenn ud zuerst Double und danach Float berechnest?

 

[eRaaaa]

Du gibst nicht die float-Time aus, sondern das float-Ergebnis
System.out.println("Float Time: " + fErg);
->
System.out.println("Float Time: " + nachher);

 

[Marco13]

In einer Millsekunde kann ein normaler PC theoretisch vielleicht so um die 1000000 floating-Point-Operationen machen. System.currentTimeMillis hat eine Auflösung von ca. 15ms (auf Windows).
(Mehr muss man eigentlich nicht sagen )

Um das zu vergleichen muss man sich etwas mehr Mühe geben....

 

[AquaBall]

Du gibst nicht die float-Time aus, sondern das float-Ergebnis
System.out.println("Float Time: " + fErg);
->
System.out.println("Float Time: " + nachher);

Nicht unbedingt "lol", aber zumindest : schmunzel.

 

[ARadauer]

Du gibst nicht die float-Time aus, sondern das float-Ergebnis

uhuu gemeiner fehler ;-)

 

[Zeitgeber]

In einer Millsekunde kann ein normaler PC theoretisch vielleicht so um die 1000000 floating-Point-Operationen machen. System.currentTimeMillis hat eine Auflösung von ca. 15ms (auf Windows).
(Mehr muss man eigentlich nicht sagen )

Um das zu vergleichen muss man sich etwas mehr Mühe geben....

1000000 FLOPS = 1 MFLOPS

Geschwindigkeit modernere Systeme nach Wikipedia

Intel Pentium 4 3,2GHz : 3-6 GFLOPS
Intel Core i7 3,2GHz 4-Core HT : 30-50 GFLOPS
Intel Core i7 3,4GHz 4-Core Sandy-Bridge : bis zu 100 GFLOPS

Deine 1 MFLOPS sind also ein wenig untertrieben ;-).

Zu System.currentTimeMillis

public class MSTest
{
	public static void main(String[] args)
	{
		for(int i=0; i<20; i++)
		{
			System.out.println(System.currentTimeMillis());
		}
	}
}

Ausgabe

1336969131631
1336969131633
1336969131633
1336969131633
1336969131633
1336969131633
1336969131633
1336969131635
1336969131635
1336969131635
1336969131635
1336969131635
1336969131635
1336969131635
1336969131635
1336969131637
1336969131637
1336969131637
1336969131639
1336969131641

erzeugt mit:
Pentium 4 3,0GHz HT
4GB DDR2-DualChannel RAM
Windows 7 Ultimate 64-Bit
Java7 Update4 64-Bit

15ms sind also etwas zu viel, 2-5ms trifft es schon eher, wobei ich bei Micro-Benchmarks wenn überhaupt System.nanoTime nutzen würde.

 

[faetzminator]

15ms sind also etwas zu viel, 2-5ms trifft es schon eher, wobei ich bei Micro-Benchmarks wenn überhaupt System.nanoTime nutzen würde.

Win XP kenn ich tatsächlich auch mit 15ms

 

[HimBromBeere]

Für solche Tests sollte man trotzdem nicht nur einen einzigen Durchlauf machen, da einfach zu viele andere Parameter mit hineinspielen. Erst häufige Widerholung (z.B. 1000 Durchläufe) bringt vergleichbare Ergebnisse.

 

[Marco13]

@Zeitgeber: Ich hatte auch die Zahlen nochmal nachgesehen - aber es sollte nur eine Größenordnung sein (bei den von dir angegebenen Zahlen schwankt es ja zwischen 3 und 100 MFLO ... nicht PS, sondern PmS ) - wie soll man solche theoretischen Zahlen auf eine teilweise interpretierte Sprache und mehrere Kerne und Multi-Threading-Betriebssysteme umrechnen....?

@HimBromBeere: Tatsächlich müßte man mindestens 2500, ggf. sogar >10000 Durchläufe machen, und vor allem die Rechnung in eine Methode packen, damit der JIT das ganze in nativen Code umwandelt...

 

[Zeitgeber]

@Zeitgeber: Ich hatte auch die Zahlen nochmal nachgesehen - aber es sollte nur eine Größenordnung sein (bei den von dir angegebenen Zahlen schwankt es ja zwischen 3 und 100 MFLO ... nicht PS, sondern PmS ) - wie soll man solche theoretischen Zahlen auf eine teilweise interpretierte Sprache und mehrere Kerne und Multi-Threading-Betriebssysteme umrechnen....?

Entschuldige, aber wie kommst du bei meinen Zahlen auf etwas zwischen 3 bis 100 MFLOPS ?
Und : es heißt schon FLOPS, laut Wikipedia : Floating Point Operations Per Second
FLOPmS würde ja dann für Per milli Second stehen, und einen Rechner der 100 MFLOp's pro MilliSekunde macht kann ich mir dann doch nur schwer vorstellen. Oder habe ich das "m" falsch interpretiert ?

Ich habe mich aber bezüglich der Leistungsfähigkeit durch Google geklickt : es gibt sogar "extreme" Systeme die die 1 Tera-FLOPS schaffen.

In wie weit man diese theoretischen Zahlen speziell auf Java und dessen VM anwenden kann ist natürlich in Punkt wo gerade solche Micro-Benchmarks überhaupt keine Aussagefähigkeit haben. Zu mal ja auch bereits JIT angesprochen wurde was ja erst bei einer gewissen Häufigkeit greift.

 

[Marco13]

Vielleicht sind 4 Stunden Schlaf DOCH zu wenig (*Augen für ein paar Sekunden zu macht und das als 'Zwinkern' bezeichnet* ) aber
1 GFLOPS = 1.000.000.000 FP Operation pro Sekunde
1 MFLOPS = 1.000.000 FP Operation pro Sekunde
1 MFLOPmS = 1.000.000 FP Operation pro milli-Sekunde
= 1.000.000.000 FP Operation pro Sekunde
= 1 GFLOPS
???:L :bahnhof:

Die Zahlen sind ja nur theoretisch. Ein Prozessor mit 3 GHz macht 3.000.000.000 Takte pro Sekunde. Die Anzahl der pro Operation benötigten Takte kann man kaum sinnvoll quantifizieren, weil sie vom Instruktionsmix und Verwendung von SIMD und mehreren Cores abhängt, aber ... sei mal vereinfachend und frei aus der Luft gegriffen angenommen, dass ein FMUL 3 Takte benötigt, dann hat er rechnerisch 1.000.000.000 FLOPS = 1 GFLOPS. Mit SIMD werden dann vielleicht 4 floats auf einmal verarbeitet, und das ganze auf 4 Cores, dann ist man bei 16 GFLOPS. Die 100 GFLOPS vom letzten erschienen mir auch unerklärlich hoch, aber ... die haben sich wohl Mühe gegeben

Die TFLOPS und PFLOPS-Systeme aus den Top500 haben diese Rechenleistungen ja auch nur theoretisch. Da wird wohl auch ziemlich pragmatisch "(Takt*Cores*SIMD)/CyclesPerOp" gerechnet, und dann freut man sich, wenn man "künstlichen" Benchmarks a la LINPACK >80% dieser theoretischen Leistung erreicht.

Wie auch immer: Der gepostete Test sagt nichts aus, mehr wollte ich eigentlich nicht sagen

 

[fastjack]

Whl. ist es einen Tick langsamer, da der double auf float convertiert wird . float f = (float) Math.sqrt(3); Bei double eben nicht.

+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
| Bench                     |   Rounds |    Objects |       ms | ms (avg) |              nt |        nt (avg) |
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
| Double                    |   10.000 |          1 |        2 |        0 |         859.363 |              85 |
| Double                    |  100.000 |          1 |        8 |        0 |       4.472.798 |              44 |
| Double                    | 1.000.000 |          1 |       67 |        0 |      26.777.320 |              26 |
| Double                    | 10.000.000 |          1 |      700 |        0 |     269.944.065 |              26 |
| Double                    | 100.000.000 |          1 |    6.973 |        0 |             ... |             ... |
| Float                     |   10.000 |          1 |        2 |        0 |         829.209 |              82 |
| Float                     |  100.000 |          1 |       16 |        0 |       4.715.182 |              47 |
| Float                     | 1.000.000 |          1 |       69 |        0 |      23.755.140 |              23 |
| Float                     | 10.000.000 |          1 |      680 |        0 |     233.446.834 |              23 |
| Float                     | 100.000.000 |          1 |    6.905 |        0 |             ... |             ... |
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
java version 1.6.0_30
Java(TM) SE Runtime Environment(build 1.6.0_30-b12)
Java HotSpot(TM) 64-Bit Server VM(build 20.5-b03, mixed mode)
Linux(3.3.0-4.fc16.x86_64) amd64
Max memory: 3562MB

16Gig RAM, 8 Core, i7-2600k CPU, 3.4Ghz
Fedora 16

    static Bench doubleBench = new AbstractBench() {
        double d1 = Math.sqrt(3);
        double d2 = Math.sqrt(5);
        double d3 = Math.sqrt(7);
        double d4 = Math.sqrt(10);
        double dErg;

        @Override
        public String getName() {
            return "Double";
        }

        @Override
        public void execute(long lm) {
            dErg = (d2-d1)*(d2-d1) + (d4-d3)* (d4-d3);
        }
    };

    static Bench floatBench = new AbstractBench() {
        float d1 = (float) Math.sqrt(3);
        float d2 = (float) Math.sqrt(5);
        float d3 = (float) Math.sqrt(7);
        float d4 = (float) Math.sqrt(10);
        float dErg;

        @Override
        public String getName() {
            return "Float";
        }

        @Override
        public void execute(long lm) {
            dErg = (d2-d1)*(d2-d1) + (d4-d3)* (d4-d3);
        }
    };

    public static void main(String[] args) {
        QuickBench.benchNxM(1000, 50000, new long[] { 10000, 100000, 1000000, 10000000, 100000000 }, new long[] { 1 }, new Bench[] { doubleBench, floatBench });
    }

P.S.: 50.000 Durchläufe als warm-up für Hotspot. Zuerst wird double getestet, dann float, dann nochmal alles inverse.

 

[Zeitgeber]

Vielleicht sind 4 Stunden Schlaf DOCH zu wenig (*Augen für ein paar Sekunden zu macht und das als 'Zwinkern' bezeichnet* ) aber
1 GFLOPS = 1.000.000.000 FP Operation pro Sekunde
1 MFLOPS = 1.000.000 FP Operation pro Sekunde
1 MFLOPmS = 1.000.000 FP Operation pro milli-Sekunde
= 1.000.000.000 FP Operation pro Sekunde
= 1 GFLOPS
???:L :bahnhof:

Die Zahlen sind ja nur theoretisch. Ein Prozessor mit 3 GHz macht 3.000.000.000 Takte pro Sekunde. Die Anzahl der pro Operation benötigten Takte kann man kaum sinnvoll quantifizieren, weil sie vom Instruktionsmix und Verwendung von SIMD und mehreren Cores abhängt, aber ... sei mal vereinfachend und frei aus der Luft gegriffen angenommen, dass ein FMUL 3 Takte benötigt, dann hat er rechnerisch 1.000.000.000 FLOPS = 1 GFLOPS. Mit SIMD werden dann vielleicht 4 floats auf einmal verarbeitet, und das ganze auf 4 Cores, dann ist man bei 16 GFLOPS. Die 100 GFLOPS vom letzten erschienen mir auch unerklärlich hoch, aber ... die haben sich wohl Mühe gegeben

Die TFLOPS und PFLOPS-Systeme aus den Top500 haben diese Rechenleistungen ja auch nur theoretisch. Da wird wohl auch ziemlich pragmatisch "(Takt*Cores*SIMD)/CyclesPerOp" gerechnet, und dann freut man sich, wenn man "künstlichen" Benchmarks a la LINPACK >80% dieser theoretischen Leistung erreicht.

Wie auch immer: Der gepostete Test sagt nichts aus, mehr wollte ich eigentlich nicht sagen

Ich glaube da hast du recht : zu viele Zahlen und zu wenig Schlaf vertragen sich nicht. Irgendwie verwirren mich diese ganzen 0en dann doch zu sehr.