if-Abfrage

[Siassei]

Hallo,

ich habe häufig den Fall, dass ich zwei Integer auf Gleichheit prüfen muss. Dabei ist folgendes Möglich
i == size
i >= size
sprich, wenn i == oder >= dann mache ...
Dabei wird i nie größer als size.

Was ist jetzt aus Sicht des Compilers besser zu optimieren? Und ja, ich weiß dass es sinnlos ist. Aber mich interessiert es halt einfach.

Gruß, Thomas

 

[Siassei]

Ein kleines Beispiel

  private[this] var menuBuffer = new Array[Menu](20)
  private[this] var menuBufferStartAt = 0

  def += (m:Menu):Int = {
    var i = menuBufferStartAt
    while(menuBuffer(i) != null) {
      i += 1
      if(i >= menuBuffer.size) {
        val t = menuBuffer
        menuBuffer = new Array[Menu](i + 20)
        Array.copy(t, 0, menuBuffer, 0, i)
      }
    }
    menuBuffer(i) = m
    i

 

[Chumax]

keins da Java-Script meist interpretiert wird. (Nur neue Browser compilieren)

Ist aber egal wie du das machst.

 

[Siassei]

keins da Java-Script meist interpretiert wird. (Nur neue Browser compilieren)

Java-Script? Wie kommst du darauf?

Ist aber egal wie du das machst[/QUTOE]
Sieht wohl so aus. Hier ein kleines Java-Beispiel mit Byte-Code

package test;

public class JTest {

	public static boolean ifStatement1(int a, int b) {
		if (a >= b)
			return true;
		else
			return false;
	}

	public static boolean ifStatement2(int a, int b) {
		if (!(a < b))
			return true;
		else
			return false;
	}

	public static boolean ifStatement3(int a, int b) {
		if (a == b)
			return true;
		else
			return false;
	}

	public static boolean ifStatement4(int a, int b) {
		if (a-b >= 0)
			return true;
		else
			return false;
	}

	public static boolean ifStatement5(int a, int b) {
		if (a-b < 0)
			return true;
		else
			return false;
	}
}

Compiliert mit Eclipse

// Compiled from JTest.java (version 1.6 : 50.0, super bit)
public class test.JTest {
  
  // Method descriptor #6 ()V
  // Stack: 1, Locals: 1
  public JTest();
    0  aload_0 [this]
    1  invokespecial java.lang.Object() [8]
    4  return
      Line numbers:
        [pc: 0, line: 3]
      Local variable table:
        [pc: 0, pc: 5] local: this index: 0 type: test.JTest
  
  // Method descriptor #15 (II)Z
  // Stack: 2, Locals: 2
  public static boolean ifStatement1(int a, int b);
    0  iload_0 [a]
    1  iload_1 [b]
    2  if_icmplt 7
    5  iconst_1
    6  ireturn
    7  iconst_0
    8  ireturn
      Line numbers:
        [pc: 0, line: 6]
        [pc: 5, line: 7]
        [pc: 7, line: 9]
      Local variable table:
        [pc: 0, pc: 9] local: a index: 0 type: int
        [pc: 0, pc: 9] local: b index: 1 type: int
      Stack map table: number of frames 1
        [pc: 7, same]
  
  // Method descriptor #15 (II)Z
  // Stack: 2, Locals: 2
  public static boolean ifStatement2(int a, int b);
    0  iload_0 [a]
    1  iload_1 [b]
    2  if_icmplt 7
    5  iconst_1
    6  ireturn
    7  iconst_0
    8  ireturn
      Line numbers:
        [pc: 0, line: 13]
        [pc: 5, line: 14]
        [pc: 7, line: 16]
      Local variable table:
        [pc: 0, pc: 9] local: a index: 0 type: int
        [pc: 0, pc: 9] local: b index: 1 type: int
      Stack map table: number of frames 1
        [pc: 7, same]
  
  // Method descriptor #15 (II)Z
  // Stack: 2, Locals: 2
  public static boolean ifStatement3(int a, int b);
    0  iload_0 [a]
    1  iload_1 [b]
    2  if_icmpne 7
    5  iconst_1
    6  ireturn
    7  iconst_0
    8  ireturn
      Line numbers:
        [pc: 0, line: 20]
        [pc: 5, line: 21]
        [pc: 7, line: 23]
      Local variable table:
        [pc: 0, pc: 9] local: a index: 0 type: int
        [pc: 0, pc: 9] local: b index: 1 type: int
      Stack map table: number of frames 1
        [pc: 7, same]
  
  // Method descriptor #15 (II)Z
  // Stack: 2, Locals: 2
  public static boolean ifStatement4(int a, int b);
     0  iload_0 [a]
     1  iload_1 [b]
     2  isub
     3  iflt 8
     6  iconst_1
     7  ireturn
     8  iconst_0
     9  ireturn
      Line numbers:
        [pc: 0, line: 27]
        [pc: 6, line: 28]
        [pc: 8, line: 30]
      Local variable table:
        [pc: 0, pc: 10] local: a index: 0 type: int
        [pc: 0, pc: 10] local: b index: 1 type: int
      Stack map table: number of frames 1
        [pc: 8, same]
  
  // Method descriptor #15 (II)Z
  // Stack: 2, Locals: 2
  public static boolean ifStatement5(int a, int b);
     0  iload_0 [a]
     1  iload_1 [b]
     2  isub
     3  ifge 8
     6  iconst_1
     7  ireturn
     8  iconst_0
     9  ireturn
      Line numbers:
        [pc: 0, line: 34]
        [pc: 6, line: 35]
        [pc: 8, line: 37]
      Local variable table:
        [pc: 0, pc: 10] local: a index: 0 type: int
        [pc: 0, pc: 10] local: b index: 1 type: int
      Stack map table: number of frames 1
        [pc: 8, same]
}

 

[Final_Striker]

Benutze die 1. oder 3. Variante. Bei den restlichen entsteht unnötiger Mehraufwand durch zusätzliche Rechenoperationen.

 

[Antoras]

Bytecode kann man nicht als Referenz nehmen um Optimierungen zu überprüfen, da dieser so gut wie nicht optimiert wird, da musst du schon auf den JIT warten.

Und selbst da bezweifle ich, dass Optimierungen vorgenommen werden, da heutige CPUs die Vergleichsoperationen bereits nativ implementieren. Da gibt es in ASM Befehle jge (jump greater equal) und jle (jump lower equal) oder eben nur die einfachen Vergleiche je (jump equal), jl (jump lower), jg (jump greater).
Bei Vergleichen der CPU werden generell verschiedene Zustandsbits (Flags) gesetzt. Bei einer einfachen equal-Abfrage reicht es ein Flag zu überprüfen, bei größer-gleich oder kleiner-gleich wird eine zusätzlich Abfrage auf ein zweites Flag benötigt.

Hier noch eine kleine Referenz.

Das einzige was man hier optimieren könnte wäre, zu prüfen ob bei einer größer-gleich-Abfrage die Werte jemals größer werden können. Wobei das bei einem Vergleich von zwei Variablen wie oben von dir gezeigt natürlich nicht möglich ist, da der Compiler hier nicht prüfen kann was für Werte diese Variablen zur Laufzeit annehmen können.