Sind kleine native Methoden lahm?


  • Mod

    Hi!

    Ich habe eben folgendes Programm geschrieben :
    [java]
    public final class MyMath
    {

    /** Creates a new instance of MyMath */
    private MyMath ()
    {
    }

    public static int max (int a, int b)
    {
    return (a > b) ? a : b;
    }

    public static void main (String [] args)
    {
    int a;
    long time = System.currentTimeMillis();
    a=0;
    for (int i = 0 ; i < 100000000 ; ++i)
    {
    a += Math.max(i,i);
    }
    System.out.println (a);
    System.out.println ("Java-Math-Zeit : " + (System.currentTimeMillis() - time));
    time = System.currentTimeMillis();
    a=0;
    for (int i = 0 ; i < 100000000 ; ++i)
    {
    a += max(i,i);
    }
    System.out.println (a);
    System.out.println ("Zeit : " + (System.currentTimeMillis() - time));
    time = System.currentTimeMillis();
    a=0;
    for (int i = 0 ; i < 100000000 ; ++i)
    {
    a += Math.max(i,i);
    }
    System.out.println (a);
    System.out.println ("Java-Math-Zeit : " + (System.currentTimeMillis() - time));
    time = System.currentTimeMillis();
    a=0;
    for (int i = 0 ; i < 100000000 ; ++i)
    {
    a += max(i,i);
    }
    System.out.println (a);
    System.out.println ("Zeit : " + (System.currentTimeMillis() - time));
    time = System.currentTimeMillis();
    a=0;
    for (int i = 0 ; i < 100000000 ; ++i)
    {
    a += Math.max(i,i);
    }
    System.out.println (a);
    System.out.println ("Java-Math-Zeit : " + (System.currentTimeMillis() - time));
    time = System.currentTimeMillis();
    a=0;
    for (int i = 0 ; i < 100000000 ; ++i)
    {
    a += max(i,i);
    }
    System.out.println (a);
    System.out.println ("Zeit : " + (System.currentTimeMillis() - time));
    }
    }[/code]
    Die Ausgabe ist :
    887459712
    Java-Math-Zeit : 6380
    887459712
    Zeit : 600
    887459712
    Java-Math-Zeit : 6370
    887459712
    Zeit : 611
    887459712
    Java-Math-Zeit : 6369
    887459712
    Zeit : 611

    Letzt gab es ja schon so eine Methode aus "Math", die so lahm war. Ich habe jetzt mal nachgeguckt, wie diese Methoden aussehen. Anscheinend werden in den Methode native Methoden aufgerufen und ich denke, dass die Methoden deshalb so langsam sind. Die Frage ist nur : Warum? Sind native Methoden eine Optimierungsgrenze, über die nicht hinwegoptimiert werden kann, oder woran liegt das? Warum werden dann in "Math" lauter native Methoden verwendet? Sollte man "Math" generell meiden, wenn man etwas schnell haben möchte?



  • Ich bin zwar keine Java-Profi, möglich aber, dass die Math Lib geschrieben wurde als noch nich gejittet wurde...


  • Mod

    * @author unascribed
    * @version 1.55, 02/06/02
    * @since JDK1.0

    Das steht im Sourcecode. ...die letzte Version ist also nicht so lange her. ...aber wahrscheinlich war es früher tatsächlich mit nativen Methoden schneller.



  • jain


  • Mod

    1. Ich habe mich komischerweise geirrt! Die Methode ist nicht native.

    2. Wenn ich die eigene Klasse als "strictfp" deklariere, dann ist java.lang.Math.max() viel schneller. ...genausoschnell, wie die selbstgeschriebene Methode letztendlich! ...ich muss mal was über dieses Schlüsselwort lernen! 🙄

    3. Die oberen beiden Punkte gelten aber nicht für Math.round und Math.floor! Die sind weiterhin langsam!

    [ Dieser Beitrag wurde am 07.01.2003 um 20:07 Uhr von Gregor editiert. ]



  • Das Schlüsselwort strictfp sagt nur aus ob Operationen strikt nach IEEE-Norm vorgehen. Bei fehlen des Schlüsselwortes werden interne "Optimierungen" gemacht.


Log in to reply