optimisation du compilateur de références

Question

J'utilise souvent des références pour simplifier l'apparence de code:

vec3f& vertex = _vertices[index]; 

// Calculate the vertex position 
vertex[0] = startx + col * colWidth; 
vertex[1] = starty + row * rowWidth; 
vertex[2] = 0.0f; 

Est-ce compilateurs reconnaître et d'optimiser cela, il est donc essentiellement les suivantes?

_vertices[index][0] = startx + col * colWidth; 
_vertices[index][1] = starty + row * rowWidth; 
_vertices[index][2] = 0.0f; 

Answer 1

Oui. C'est une optimisation de base que tout compilateur moderne (et même ancien) fera.

En fait, je ne pense pas qu'il soit vraiment précis d'appeler que vous avez écrit une optimisation, puisque la façon simple de traduire cela en assembly implique un stockage à l'adresse _vertex, plus index, plus {0, 1,2} (multiplié par les tailles appropriées pour les choses, bien sûr).

En général cependant, les compilateurs modernes sont incroyable. Presque toute l'optimisation que vous pouvez imaginer sera mise en œuvre. Vous devriez toujours écrire votre code d'une manière qui met l'accent sur la lisibilité, à moins que vous sachiez que d'une manière a des avantages significatifs de performance pour votre code.

Comme un exemple simple, le code comme ceci:

int func() { 
    int x; 
    int y; 
    int z; 
    int a; 

    x = 5*5; 
    y = x; 
    z = y; 
    a = 100 * 100 * 100* 100; 

    return z; 
} 

sera optimisé à ceci:

int func() { 
    return 25 
} 

De plus, le compilateur inline également la fonction de sorte qu'aucun appel est en fait. Au lieu de cela, partout 'func()' apparaîtra sera simplement remplacé par '25'.

Ceci est juste un exemple simple. Il y a beaucoup plus d'optimisations complexes qu'un compilateur moderne implémente.

Answer 2

Les compilateurs feront même plus de choses intelligentes que cela. Peut-être qu'ils vont faire

vec3f * vertex = _vertices[index]; 

*vertex++ = startx + col * colWidth; 
*vertex++ = starty + row * rowWidth; 
*vertex++ = 0.0f; 

ou même d'autres variations ...

Answer 3

Selon les types de variables, ce que vous avez décrit est une pessimisation.

Si vertices est un type de classe, votre formulaire d'origine effectue un seul appel à operator[] et réutilise la référence renvoyée. Votre deuxième formulaire fait trois appels distincts. On ne peut pas nécessairement déduire que la référence renvoyée se rapportera au même objet à chaque fois.

Le coût d'une référence n'est probablement pas important par rapport aux recherches répétées dans l'objet original vertices. Sauf dans des cas limités, le compilateur ne peut pas optimiser (ou pessimiser) les appels de fonction supplémentaires, à moins que la modification introduite ne soit pas détectable par un programme conforme. Cela nécessite souvent la visibilité d'une définition en ligne.

Ceci est connu comme la règle "as if". Tant que le code se comporte comme si les règles de langage ont été suivies exactement, l'implémentation peut faire toutes les optimisations qu'il juge appropriées.