Grande differenza di velocità di metodi statici e non statici equivalenti

In questo codice, quando creo un oggetto nel mainmetodo e quindi chiamo il metodo degli oggetti: ff.twentyDivCount(i)(viene eseguito in 16010 ms), viene eseguito molto più velocemente rispetto a chiamarlo utilizzando questa annotazione: twentyDivCount(i)(viene eseguito in 59516 ms). Ovviamente, quando lo eseguo senza creare un oggetto, rendo il metodo statico, quindi può essere chiamato nel main.

public class ProblemFive {

    // Counts the number of numbers that the entry is evenly divisible by, as max is 20
    int twentyDivCount(int a) {    // Change to static int.... when using it directly
        int count = 0;
        for (int i = 1; i<21; i++) {

            if (a % i == 0) {
                count++;
            }
        }
        return count;
    }

    public static void main(String[] args) {
        long startT = System.currentTimeMillis();;
        int start = 500000000;
        int result = start;

        ProblemFive ff = new ProblemFive();

        for (int i = start; i > 0; i--) {

            int temp = ff.twentyDivCount(i); // Faster way
                       // twentyDivCount(i) - slower

            if (temp == 20) {
                result = i;
                System.out.println(result);
            }
        }

        System.out.println(result);

        long end = System.currentTimeMillis();;
        System.out.println((end - startT) + " ms");
    }
}

EDIT: Finora sembra che macchine diverse producano risultati diversi, ma usando JRE 1.8. * È dove il risultato originale sembra essere riprodotto in modo coerente.

Utilizzando JRE 1.8.0_45 ottengo risultati simili.

Indagine:

1. l'esecuzione di java con le -XX:+UnlockDiagnosticVMOptions -XX:+PrintCompilation -XX:+PrintInliningopzioni VM mostra che entrambi i metodi vengono compilati e inline
2. Guardando l'assembly generato per i metodi stessi non mostra differenze significative
3. Una volta che vengono inseriti inline, tuttavia, l'assembly generato all'interno mainè molto diverso, con il metodo dell'istanza ottimizzato in modo più aggressivo, specialmente in termini di srotolamento del loop

Ho quindi eseguito di nuovo il test ma con diverse impostazioni di srotolamento del ciclo per confermare il sospetto sopra. Ho eseguito il tuo codice con:

• -XX:LoopUnrollLimit=0 ed entrambi i metodi vengono eseguiti lentamente (simile al metodo statico con le opzioni predefinite).
• -XX:LoopUnrollLimit=100 ed entrambi i metodi vengono eseguiti velocemente (simile al metodo di istanza con le opzioni predefinite).

In conclusione sembra che, con le impostazioni predefinite, il JIT dell'hotspot 1.8.0_45 non sia in grado di srotolare il ciclo quando il metodo è statico (anche se non sono sicuro del motivo per cui si comporta in questo modo). Altre JVM possono produrre risultati diversi.

Solo un'ipotesi non dimostrata basata su una risposta di Assylias.

La JVM utilizza una soglia per lo srotolamento del loop, che è qualcosa come 70. Per qualsiasi motivo, la chiamata statica è leggermente più grande e non viene srotolata.

Aggiorna i risultati

• Con il LoopUnrollLimitsotto 52, entrambe le versioni sono lente.
• Tra 52 e 71, solo la versione statica è lenta.
• Sopra 71, entrambe le versioni sono veloci.

Questo è strano poiché la mia ipotesi era che la chiamata statica fosse solo leggermente più grande nella rappresentazione interna e l'OP avesse colpito uno strano caso. Ma la differenza sembra essere di circa 20, il che non ha senso.

-XX:LoopUnrollLimit=51
5400 ms NON_STATIC
5310 ms STATIC
-XX:LoopUnrollLimit=52
1456 ms NON_STATIC
5305 ms STATIC
-XX:LoopUnrollLimit=71
1459 ms NON_STATIC
5309 ms STATIC
-XX:LoopUnrollLimit=72
1457 ms NON_STATIC
1488 ms STATIC

Per coloro che desiderano sperimentare, la mia versione può essere utile.

Quando viene eseguito in modalità debug, i numeri sono gli stessi per l'istanza e per i casi statici. Ciò significa inoltre che JIT esita a compilare il codice in codice nativo nel caso statico allo stesso modo del caso del metodo di istanza.

Perché lo fa? È difficile da dire; probabilmente farebbe la cosa giusta se questa fosse un'applicazione più grande ...

Ho appena modificato leggermente il test e ho ottenuto i seguenti risultati:

Produzione:

Dynamic Test:
465585120
232792560
232792560
51350 ms
Static Test:
465585120
232792560
232792560
52062 ms

NOTA

Mentre li stavo testando separatamente ho ottenuto ~ 52 sec per dinamico e ~ 200 sec per statico.

Questo è il programma:

public class ProblemFive {

    // Counts the number of numbers that the entry is evenly divisible by, as max is 20
    int twentyDivCount(int a) {  // Change to static int.... when using it directly
        int count = 0;
        for (int i = 1; i<21; i++) {

            if (a % i == 0) {
                count++;
            }
        }
        return count;
    }

    static int twentyDivCount2(int a) {
         int count = 0;
         for (int i = 1; i<21; i++) {

             if (a % i == 0) {
                 count++;
             }
         }
         return count;
    }

    public static void main(String[] args) {
        System.out.println("Dynamic Test: " );
        dynamicTest();
        System.out.println("Static Test: " );
        staticTest();
    }

    private static void staticTest() {
        long startT = System.currentTimeMillis();;
        int start = 500000000;
        int result = start;

        for (int i = start; i > 0; i--) {

            int temp = twentyDivCount2(i);

            if (temp == 20) {
                result = i;
                System.out.println(result);
            }
        }

        System.out.println(result);

        long end = System.currentTimeMillis();;
        System.out.println((end - startT) + " ms");
    }

    private static void dynamicTest() {
        long startT = System.currentTimeMillis();;
        int start = 500000000;
        int result = start;

        ProblemFive ff = new ProblemFive();

        for (int i = start; i > 0; i--) {

            int temp = ff.twentyDivCount(i); // Faster way

            if (temp == 20) {
                result = i;
                System.out.println(result);
            }
        }

        System.out.println(result);

        long end = System.currentTimeMillis();;
        System.out.println((end - startT) + " ms");
    }
}

Ho anche cambiato l'ordine del test in:

public static void main(String[] args) {
    System.out.println("Static Test: " );
    staticTest();
    System.out.println("Dynamic Test: " );
    dynamicTest();
}

E ho capito:

Static Test:
465585120
232792560
232792560
188945 ms
Dynamic Test:
465585120
232792560
232792560
50106 ms

Come vedi, se dinamico viene chiamato prima di statico, la velocità per statica diminuisce drasticamente.

Sulla base di questo benchmark:

Io ipotizzo che tutto dipende l'ottimizzazione JVM. quindi ti consiglio solo di seguire la regola pratica per l'uso di metodi statici e dinamici.

REGOLA DEL POLLICE:

Java: quando utilizzare metodi statici

Vi preghiamo di provare:

public class ProblemFive {
    public static ProblemFive PROBLEM_FIVE = new ProblemFive();

    public static void main(String[] args) {
        long startT = System.currentTimeMillis();
        int start = 500000000;
        int result = start;


        for (int i = start; i > 0; i--) {
            int temp = PROBLEM_FIVE.twentyDivCount(i); // faster way
            // twentyDivCount(i) - slower

            if (temp == 20) {
                result = i;
                System.out.println(result);
                System.out.println((System.currentTimeMillis() - startT) + " ms");
            }
        }

        System.out.println(result);

        long end = System.currentTimeMillis();
        System.out.println((end - startT) + " ms");
    }

    int twentyDivCount(int a) {  // change to static int.... when using it directly
        int count = 0;
        for (int i = 1; i < 21; i++) {

            if (a % i == 0) {
                count++;
            }
        }
        return count;
    }
}