Discussion :

[le y@m's]

salut a tous,
je souhaiterai avoir quelques precisions sur la declaration de fonction inline.
Après consultation de la faq, j'ai compris que la declaration des fonction inline peut augmenter
comme baisser les performances d'une apllication mais je n'ai pas bien saisi les raisons de ces comportements.
est-ce un trop grand nombre de fonction ou des fonctions appelées trop souvent (ou les deux) qui peuvent reduire la perf ?
ou bien encore d'autres choses ?
(en partant du principe que ces fonctions ne comporte qu'1 seule ligne de code).
merci d'avance.

[tut]

l'utilisation de inline peut réduire les perfs si elle engendre une augmentation de taille du code de l'executable de manière très importante, pouvant par exemple, entraîner une pagination de la mémoire, si tu n'as pas de bol.
Pour syntétiser :

Il n'y a pas de réponse simple : vous devez essayer et voir ce qui est le mieux. Ne vous limitez pas à des réponses simplistes telles que "Ne jamais utiliser les fonctions inline" ou "Toujours utiliser les fonctions inline" ou "N'utiliser les fonctions inline que si le code fait moins de ... lignes de code". Ces règles arbitraires sont peut-être faciles à écrire, mais les résultats sont plus que décevants.

et encore plus simple : si tu as un compilateur digne de ce nom et correctement utilisé, il se chargera tout seul comme un grand de mettre les fonctions inline nécessaires.

[Charlemagne]

Si la vitesse est importante, il vaut mieux avoir un exécutable plus gros.
Car d'après mon expérience, Il n'y a rien de plus lent qu'un appel de fonction ou qu'un saut (if/for/while).
Le pipeline du processeur est brisé est ça coute cher en temps d'exécution. Plus le processeur est évolué (pentium 4) plus c'est pire, même si le processeur est soi disant capable de faire une pré-évaluation des conditions de saut.

[Selenite]

Si la vitesse est importante, il vaut mieux avoir un exécutable plus gros.
Car d'après mon expérience, Il n'y a rien de plus lent qu'un appel de fonction ou qu'un saut (if/for/while).
Le pipeline du processeur est brisé est ça coute cher en temps d'exécution. Plus le processeur est évolué (pentium 4) plus c'est pire, même si le processeur est soi disant capable de faire une pré-évaluation des conditions de saut.

Il vaut mieux avoir un éxécutable un petit peu plus gros. Mettre de grosses fonctions inline peut vraiment faire baisser les performances.
Quand à la prévison des saut conditionnels, la règle est simple: les sauts en avant sont considérés comme n'étant pas pris, les saut en arrière si. (On rajoute à cela un petit peu de mémoire si un saut en avant à été pris, le processeur le saura pour la prochaine fois.)

[HRS]

si la fonction est appelée dans une boucle qui se deroule un milliard de fois,
cela vaut peut-être le coup de la mettre inline. De toute façon, c'est le
compilateur qui décide de tenir compte ou non de cette directive

[Charlemagne]

En général c'est bien le compilateur qui décide, mais il y a des options de compilation pour le mettre sur la voie.
Et puis sous Visual (puisqu'il programme sous Visual), il ya surtout la directive '__forceinline', mais c'est pas standard

[le y@m's]

Et puis sous Visual (puisqu'il programme sous Visual)

Depuis quand ? (j'utilise devcpp)

si la fonction est appelée dans une boucle qui se deroule un milliard de fois,
cela vaut peut-être le coup de la mettre inline

Donc declarer inline une fonction appellée fréquemment a plutot tendance à augmenter les perfs

[Charlemagne]

Désolé, j'ai mal lu, ou confondu avec quelqu'un d'autre. Il m'avait semblé que tu étais sous Visual.

Dans l'ensemble, je dirais ne pas hésiter à déclarer une fonction en inline. De toute facon le compilateur n'en fait souvent qu'à sa tête.
A part debugger le programme dans le mode release (c'est possible sous Visual ou Intel Compiler), je vois pas comment faire pour s'assurer qu'une fonction a bien été réellement mise inline.
Grace a la directive __forceinline, j'ai souvent des gains d'au moins 50%.

Finallement, je pense c'est un test de rapidité de ton programme qui dictera quels options de compilation choisir

[le y@m's]

merci a tous pour vos reponses

[le y@m's]

je marque le sujet resolu mais faut pas hesiter à rajouter des commentaires.

[Selenite]

Voici deux cas:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
for ( ; ; )
    f(x);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
f(a);
f(b);
f(c);
f(d);
f(e);
...

Dans le premier cas, mettre f en inline sera une bonne idée. Dans le second cas, probablement non. A l'éxécution du programme, charger le code est une opération qui coute du temps. Une fonction qui est beaucoup appelée, mais pas peu de points d'appel est une bonne condidate à l'inline.
Essayez pour voir ce code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
f(x);
f(x);

La première exécution de f sera bien plus lente que la seconde.

[koushkov]

Désolé de ressortir le sujet mais, si je comprends bien, utiliser des fonctions inline augmente le temps de chargement de l'exe et une fois qu'il est chargé, l'exécution est plus rapide. Il faut donc un bon compromis entre les deux.

Autrement dit, si j'utilise des fonctions qui font des tests sans arrêt, avec des boucles infinies, en la laissant exécuter longtemps (des dizaines d'heures), le mieux serait alors de mettre du inline partout.

[b Oo]

De toute façon, c'est le
compilateur qui décide de tenir compte ou non de cette directive

Salut,
j'entends dire que le compilateur choisit si une fonction est inline ou non.
Pourtant je ne suis pas sûr que ce soit le cas, il me semble que lorsqu'une fonction est déclarée inline (ou définie dans une classe) alors elle est inline.

Personnellement, je mets une méthode inline lorsque celle-ci fait par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
class A
{
    int a;
  public;
    int getInt() const { return a; }
};

Bonne soirée.

b Oo