Reprise du message précédent :
Je sais que l'inline peut faire perdre des perfs quand ça cause des cache miss sur le code.

ouais mais des caches miss qui cause 10% de pertes
En plus les ultra sparc ca a bcp de cache non ?

Les cache miss, ca peut aller très loin. Il suffit que la fonction soit assez grosse et appelée à assez d'endroits differents dans le code.
 
Par exemple, si avant inline un algo gourmand en itérations tenait entièrement dans le cache ( code plus données à traiter ), mais qu'après inline il n'y tiend plus => très grosse chute de perfs.

vi.
 
de toutes façon, part du principe qu'a partir du moment ou tu as un boucle de traitement, le inline est inutile et générateur de pertes de perf.
 
par exemple:
 
class truc
{
public:
  float machin;
 
  inline mets_au_carré()
  {
    machin*=machin;
  }
};
 
class vector_de_trucs : public vector<truc>
{
  public:
 
  mets_tout_au_carré()
  {
     for( int i=0 ; i < Size() ; i++ )
         operator [](i).mets_au_carré();
  }
};
 
bon c'est du code porc (rien à fout si ça compile po)
mais dans l'idée pour avoir qqchose de performant fo que truc::mets_au_carré() soit inliné, mais pas vector_de_trucs::mets_tout_au_carré SAUF si il est utilisé qu'une fois dans tout le prog (difficile).
 
dans le cas de mets_au_carré() le temps d'un CALL/RET sera bien trop important devant la méthode elle-même, par contre dans le cas de mets_tout_au_carré() il sera insignifiant si le vector contient pas mal d'éléments, et un inline abusif fera décoller l'utilisation mémoire (et donc le trash du cache code) si la méthode est utilisé à de nombreux endroits...
 
inliner une méthode qui utilsée dans une boucle est aussi utile dans le sens ou en plus de dégager le couple call/ret, le compilo intègre les instructions de la méthodes dans la boucle, est génère un flux d'instruction optimal pour le CPU .

merci pour les précisions

Mais euh ! J'étais obligé m'sieur, j'ai des circonstances atténuantes.
 

inline permet de partager la fonction par header.
Une fonction standard ne peut être inlinée dans des sources qui n'ont que sa déclaration.
 
 

Se permettre de rester en C a un coût.
 

Se serait plus sûr comme ça:

Il est possible que le compilateur, ne sachant pas inliner une variable statique, aie compilé une copie de la fonction pour chaque source : encombrement du cache par copies multiples.
 
 

Malheureux ! Tu tiens vraiment à te faire tabasser ?

Je viens juste de lire une "doc" sur comment inliner dans "Efficient C++", et en gros, il n'y a que 2 types de fonctions qu'il faut faire inline d'office :
 
- Les fonctions tellement petites qu'une fois inliné, son utilisation prend moins de place mémoire que de faire un appel de   fonction. Mention spéciale pour toutes les fonctions accesseur classiques en C++ comme GetValeur().
- Les fonctions utilisées une seule fois dans tout le projet, quel que soit leur taille.
 
Après, pour les tailles intermédiares, il faut voir au cas par cas.  
 
Les 2 interet de inline sont :
- Économiser les instructions d'appel de fonction/retour d'appel.
- Faire des optimisations plus sioux que si il n'y avait pas inline. Le code de ce genre :

Ça s'optimise très bien, et ça peut arriver plus souvent que l'on ne le pense quand on fait de l'inline.

Bah alors, si son compilo supporte pas le inline, explique comment t'aurais procédé.. (à part changer de compilo bien sûr )

Ce sont des optimisations dites 'à travers' l'appel.
À ce qu'il paraît c'est la principale source d'optimisation.
 

*Syl* a écrit a écrit : Bah alors, si son compilo supporte pas le inline, explique comment t'aurais procédé.. (à part changer de compilo bien sûr )

-changer de compilo .
-renoncer à inline.
-macro. Mais j'ai pris la bonne résolution de les éviter.

Pkoi éviter les macros ?

 
c'est quand meme pas franchement super propre (Y'a des fois ou ca sauve la vie, en particulier j'ai un fichier limite fait a la macro (mais j'ai honte))

D'un autre côté, la fonction inline permet des optimisations spéciales si les arguments sont constants. Le déroulage de boucle entre-autres.
 
En fait, en C++ inline n'est pas un ordre.
Un bon compilateur est capable de créer la fonction en vrai s'il l'estime préférable.
D'autant plus que c'est basé sur le même mécanisme que les templates : compilation dans chaque source (plus lente), et fusion à la liaison.
 
La fonction peut même être inlinées à certains endroits et pas à d'autres.
Une méthode virtuelle inline par exemple.
 
 
 

Pour ça:

Les deux premiers s'évitent comme ça:

Les deux suivants ne s'évitent pas, c'est pourquoi cette macros est en majuscules : signaler qu'elle est une macro dangereuse.