Ist das ein legitimer Test?

[Willibergi]

Ich wollte mal testen, wie viel Zeitverlust ein else continue; in einer for-Schleife mit sich bringt.

Ich habe dazu folgendes Programm geschrieben:

package programs;

import java.time.Duration;
import java.time.Instant;

public class LaufzeitTest {

    public static void main(String[] args){

        int a = 0, b = 0;
        int limit = 2_000_000_000;

        Instant i1 = Instant.now();

        for(int i=0; i < limit; i++){

            if(i%2 == 0) a++;
            else continue;

        }

        Instant i2 = Instant.now();
        a = 0;
        Instant i3 = Instant.now();

        for (int i=0; i < limit; i++) {

            if(i%2 == 0) a++;

        }

        Instant i4 = Instant.now();

        Duration dur1 = Duration.between(i1, i2);
        Duration dur2 = Duration.between(i3, i4);

        double d1 = Double.parseDouble(dur1.toString().substring(3, dur1.toString().length()-1));
        double d2 = Double.parseDouble(dur2.toString().substring(3, dur2.toString().length()-1));

        System.out.printf("Mit \"else continue;\": %fs%nOhne \"else continue;\": %fs%nDifferenz: %fs%n =>Um %f%% schneller!", d1, d2, d2-d1, (d2-d1)/d2*100);

    }

}

Meistens ist die Schleife ohne else continue; um ca. eine halbe Sekunde also um 50-60% schneller als die mit.

Nur bin ich mir nicht ganz sicher, ob das alles stimmt.

Ich meine, 50-60% ist schon richtig viel - nur dafür, dass die Schleife sowieso das tut was sie auch sonst täte, oder?

Drum wollte ich hier noch mal ein paar Profis drüberschauen lassen, ob das alles stimmt und ob damit auch mein Ergebnis stimmt.

Danke schonmal im Voraus.

 

[Joose]

.... nur dafür, dass die Schleife sowieso das tut was sie auch sonst täte, oder?

Sie tut für dich vielleicht das selbe, aber im bytecode wird das schon anders ausschauen

 

[Flown]

Definitiv ist das kein gelungener Benchmarktest. Benutz doch Microbenchmark-Tools die dir das alles abnehmen, denn meistens misst du JVM Aktivitäten wie JIT/GC/etc...
Auf SO sind hier Tutorials wie das am besten gemacht wird.

Ich nutz für sowas immer JMH.
Code würde dann so aussehen:

import java.util.concurrent.TimeUnit;

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;

@Fork(3)
@BenchmarkMode(Mode.AverageTime)
@Measurement(iterations = 10, timeUnit = TimeUnit.NANOSECONDS)
@State(Scope.Benchmark)
@Threads(1)
@Warmup(iterations = 5, timeUnit = TimeUnit.NANOSECONDS)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class MyBenchmark {
 
  private final int LIMIT = 2_000_000_000;
 
  @Benchmark
  public int forContinue() {
    int a = 0;
    for (int i = 0; i < LIMIT; i++) {
      if (i % 2 == 0) {
        a++;
      } else {
        continue;
      }
     
    }
    return a;
  }
 
  @Benchmark
  public int forWOContinue() {
    int a = 0;
    for (int i = 0; i < LIMIT; i++) {
      if (i % 2 == 0) {
        a++;
      }
    }
    return a;
  }
}

und das Ergebnis:

Benchmark                  Mode  Cnt           Score         Error  Units
MyBenchmark.forContinue    avgt   30  1387601172,333 ± 6900383,114  ns/op
MyBenchmark.forWOContinue  avgt   30  1375414436,200 ± 6594290,245  ns/op

Interpretation: Beide Arten sind gleichwertig und es gibt kaum bis keinen Unterschied.

 

[Meniskusschaden]

Ich habe mir mal den Bytecode angesehen. Das bestätigt das Ergebnis von @Flown. Hier ist der Bytecode der ersten Schleife:

     12  iconst_0
     13  istore 5 [i]
     15  goto 31
     18  iload 5 [i]
     20  iconst_2
     21  irem
     22  ifne 28
     25  iinc 1 1 [a]
     28  iinc 5 1 [i]
     31  iload 5 [i]
     33  iload_3 [limit]
     34  if_icmplt 18

Und hier der Bytecode der zweiten Schleife:

     49  iconst_0
     50  istore 7 [i]
     52  goto 68
     55  iload 7 [i]
     57  iconst_2
     58  irem
     59  ifne 65
     62  iinc 1 1 [a]
     65  iinc 7 1 [i]
     68  iload 7 [i]
     70  iload_3 [limit]
     71  if_icmplt 55

Es gibt offenbar keinen strukturellen Unterschied. Nur Zeilennummern und Variablen weichen logischerweise voneinander ab. Der Compiler optimiert den überflüssigen else-Zweig offenbar weg.
Zur Info noch der vollständige Bytecode:

// Compiled from LaufzeitTest.java (version 1.8 : 52.0, super bit)
public class programs.LaufzeitTest {

  // Method descriptor #6 ()V
  // Stack: 1, Locals: 1
  public LaufzeitTest();
    0  aload_0 [this]
    1  invokespecial java.lang.Object() [8]
    4  return
      Line numbers:
        [pc: 0, line: 6]
      Local variable table:
        [pc: 0, pc: 5] local: this index: 0 type: programs.LaufzeitTest

  // Method descriptor #15 ([Ljava/lang/String;)V
  // Stack: 9, Locals: 14
  public static void main(java.lang.String[] args);
      0  iconst_0
      1  istore_1 [a]
      2  iconst_0
      3  istore_2 [b]
      4  ldc <Integer 2000000000> [16]
      6  istore_3 [limit]
      7  invokestatic java.time.Instant.now() : java.time.Instant [17]
     10  astore 4 [i1]
     12  iconst_0
     13  istore 5 [i]
     15  goto 31
     18  iload 5 [i]
     20  iconst_2
     21  irem
     22  ifne 28
     25  iinc 1 1 [a]
     28  iinc 5 1 [i]
     31  iload 5 [i]
     33  iload_3 [limit]
     34  if_icmplt 18
     37  invokestatic java.time.Instant.now() : java.time.Instant [17]
     40  astore 5 [i2]
     42  iconst_0
     43  istore_1 [a]
     44  invokestatic java.time.Instant.now() : java.time.Instant [17]
     47  astore 6 [i3]
     49  iconst_0
     50  istore 7 [i]
     52  goto 68
     55  iload 7 [i]
     57  iconst_2
     58  irem
     59  ifne 65
     62  iinc 1 1 [a]
     65  iinc 7 1 [i]
     68  iload 7 [i]
     70  iload_3 [limit]
     71  if_icmplt 55
     74  invokestatic java.time.Instant.now() : java.time.Instant [17]
     77  astore 7 [i4]
     79  aload 4 [i1]
     81  aload 5 [i2]
     83  invokestatic java.time.Duration.between(java.time.temporal.Temporal, java.time.temporal.Temporal) : java.time.Duration [23]
     86  astore 8 [dur1]
     88  aload 6 [i3]
     90  aload 7 [i4]
     92  invokestatic java.time.Duration.between(java.time.temporal.Temporal, java.time.temporal.Temporal) : java.time.Duration [23]
     95  astore 9 [dur2]
     97  aload 8 [dur1]
     99  invokevirtual java.time.Duration.toString() : java.lang.String [29]
    102  iconst_3
    103  aload 8 [dur1]
    105  invokevirtual java.time.Duration.toString() : java.lang.String [29]
    108  invokevirtual java.lang.String.length() : int [33]
    111  iconst_1
    112  isub
    113  invokevirtual java.lang.String.substring(int, int) : java.lang.String [39]
    116  invokestatic java.lang.Double.parseDouble(java.lang.String) : double [43]
    119  dstore 10 [d1]
    121  aload 9 [dur2]
    123  invokevirtual java.time.Duration.toString() : java.lang.String [29]
    126  iconst_3
    127  aload 9 [dur2]
    129  invokevirtual java.time.Duration.toString() : java.lang.String [29]
    132  invokevirtual java.lang.String.length() : int [33]
    135  iconst_1
    136  isub
    137  invokevirtual java.lang.String.substring(int, int) : java.lang.String [39]
    140  invokestatic java.lang.Double.parseDouble(java.lang.String) : double [43]
    143  dstore 12 [d2]
    145  getstatic java.lang.System.out : java.io.PrintStream [49]
    148  ldc <String "Mit \"else continue;\": %fs%nOhne \"else continue;\": %fs%nDifferenz: %fs%n =>Um %f%% schneller!"> [55]
    150  iconst_4
    151  anewarray java.lang.Object [3]
    154  dup
    155  iconst_0
    156  dload 10 [d1]
    158  invokestatic java.lang.Double.valueOf(double) : java.lang.Double [57]
    161  aastore
    162  dup
    163  iconst_1
    164  dload 12 [d2]
    166  invokestatic java.lang.Double.valueOf(double) : java.lang.Double [57]
    169  aastore
    170  dup
    171  iconst_2
    172  dload 12 [d2]
    174  dload 10 [d1]
    176  dsub
    177  invokestatic java.lang.Double.valueOf(double) : java.lang.Double [57]
    180  aastore
    181  dup
    182  iconst_3
    183  dload 12 [d2]
    185  dload 10 [d1]
    187  dsub
    188  dload 12 [d2]
    190  ddiv
    191  ldc2_w <Double 100.0> [61]
    194  dmul
    195  invokestatic java.lang.Double.valueOf(double) : java.lang.Double [57]
    198  aastore
    199  invokevirtual java.io.PrintStream.printf(java.lang.String, java.lang.Object[]) : java.io.PrintStream [63]
    202  pop
    203  return
      Line numbers:
        [pc: 0, line: 9]
        [pc: 4, line: 10]
        [pc: 7, line: 11]
        [pc: 12, line: 12]
        [pc: 18, line: 14]
        [pc: 28, line: 12]
        [pc: 37, line: 18]
        [pc: 42, line: 19]
        [pc: 44, line: 20]
        [pc: 49, line: 21]
        [pc: 55, line: 22]
        [pc: 65, line: 21]
        [pc: 74, line: 25]
        [pc: 79, line: 26]
        [pc: 88, line: 27]
        [pc: 97, line: 28]
        [pc: 121, line: 29]
        [pc: 145, line: 30]
        [pc: 203, line: 32]
      Local variable table:
        [pc: 0, pc: 204] local: args index: 0 type: java.lang.String[]
        [pc: 2, pc: 204] local: a index: 1 type: int
        [pc: 4, pc: 204] local: b index: 2 type: int
        [pc: 7, pc: 204] local: limit index: 3 type: int
        [pc: 12, pc: 204] local: i1 index: 4 type: java.time.Instant
        [pc: 15, pc: 37] local: i index: 5 type: int
        [pc: 42, pc: 204] local: i2 index: 5 type: java.time.Instant
        [pc: 49, pc: 204] local: i3 index: 6 type: java.time.Instant
        [pc: 52, pc: 74] local: i index: 7 type: int
        [pc: 79, pc: 204] local: i4 index: 7 type: java.time.Instant
        [pc: 88, pc: 204] local: dur1 index: 8 type: java.time.Duration
        [pc: 97, pc: 204] local: dur2 index: 9 type: java.time.Duration
        [pc: 121, pc: 204] local: d1 index: 10 type: double
        [pc: 145, pc: 204] local: d2 index: 12 type: double
      Stack map table: number of frames 6
        [pc: 18, full, stack: {}, locals: {java.lang.String[], int, int, int, java.time.Instant, int}]
        [pc: 28, same]
        [pc: 31, same]
        [pc: 55, full, stack: {}, locals: {java.lang.String[], int, int, int, java.time.Instant, java.time.Instant, java.time.Instant, int}]
        [pc: 65, same]
        [pc: 68, same]
}

 

[Willibergi]

Definitiv ist das kein gelungener Benchmarktest. Benutz doch Microbenchmark-Tools die dir das alles abnehmen

Aber was macht das für einen Unterschied? Im Prinzip ist die Vorgehensweise ja klar - ich gucke wie lange die eine Schleife braucht, dann wie lange die andere Schleife braucht und dann sehe ich welche effizienter ist.
Was machen Microbenchmark-Tools grundsätzlich anders?

 

[Flown]

Benchmarktools messen den Algorithmus und verhindern, dass du JVM Aktivität misst, wie ich im letzten Post beschrieben hab.