L'optimiseur JIT optimise-t-il la multiplication?

Question

Dans mon cours d'architecture informatique, je viens d'apprendre qu'exécuter une expression algébrique impliquant une multiplication par un circuit de multiplication peut être plus coûteux que de l'exécuter par un circuit additionnel si le nombre de multiplications requises est inférieur à 3. Si je fais ce type de calcul quelques milliards de fois, est-ce payant de l'écrire comme: x + x + x ou l'optimiseur JIT optimise-t-il cela?

Answer 1

Je ne m'attendrais pas à être une énorme différence en l'écrivant dans un sens ou dans l'autre.

Le compilateur prendra probablement soin de faire tous ces équivalents.

Vous pouvez essayer chaque méthode et mesurer combien de temps cela prend, ce qui pourrait vous donner un bon indice pour répondre à votre propre question.

Voici un code qui fait les mêmes calculs 10 millions de fois en utilisant différentes approches (x + x + x, 3 * x, et un décalage de bit suivi d'une soustraction). Ils semblent prendre le même temps que mesuré par System.nanoTime.

Exemple de sortie pour une course:

sum : 594599531 
mult : 568783654 
shift : 564081012 

Vous pouvez également jeter un oeil à cette question qui parle de la façon dont l'optimisation du compilateur peut probablement gérer ceux-ci et des cas plus complexes: Is shifting bits faster than multiplying and dividing in Java? .NET?

code:

import java.util.Random; 

    public class TestOptimization { 

     public static void main(String args[]) { 
      Random rn = new Random(); 
      long l1 = 0, l2 = 0, l3 = 0; 
      long nano1 = System.nanoTime(); 
      for (int i = 1; i < 10000000; i++) { 
       int num = rn.nextInt(100); 
       l1 += sum(num); 
      } 
      long nano2 = System.nanoTime(); 
      for (int i = 1; i < 10000000; i++) { 
       int num = rn.nextInt(100); 
       l2 += mult(num); 
      } 
      long nano3 = System.nanoTime(); 
      for (int i = 1; i < 10000000; i++) { 
       int num = rn.nextInt(100); 
       l3 += shift(num); 
      } 
      long nano4 = System.nanoTime(); 
      System.out.println(l1); 
      System.out.println(l2); 
      System.out.println(l3); 
      System.out.println("sum : " + (nano2 - nano1)); 
      System.out.println("mult : " + (nano3 - nano2)); 
      System.out.println("shift : " + (nano4 - nano3)); 
     } 

     private static long sum(long x) { 
      return x + x + x; 
     } 

     private static long mult(long x) { 
      return 3 * x; 
     } 

     private static long shift(long x) { 
      return (x << 2) - x; 
     } 

    }