Compilateur C++ - Optimisations

De Appmethod Topics
Aller à : navigation, rechercher

Remonter à Options de projet du compilateur C++


Projet > Options > Compilateur C++ > Optimisations

Utilisez cette boîte de dialogue pour définir les options d'optimisation du compilateur C++.

Options Description

Cible, Appliquer, Enregistrer

Voir Options de la cible.

Eléments communs

Voir Eléments communs des pages Options de projet.


Options d'optimisation Description Support du compilateur
bcc32 bcc64 bccosx bcciosarm bcciosarm64 bccaarm

Désactiver toutes les optimisations

Désactive tous les paramètres d'optimisation, notamment ceux que vous avez spécifiquement définis ou qui sont normalement activés dans le cadre d'une optimisation qui privilégie la vitesse ou la taille. Comme cette option désactive le compactage du code et les optimisations de branchement, elle empêche les sauts inopinés du débogueur d'une fonction à une autre sans avertissement et facilite notablement le suivi de l'exécution. Valeur par défaut = True

YesC++11Feature.png
YesC++11Feature.png
YesC++11Feature.png
YesC++11Feature.png
YesC++11Feature.png
YesC++11Feature.png

Activer les optimisations sélectionnées

Active seulement les optimisations que vous sélectionnez dans la liste secondaire des optimisations. Valeur par défaut = False

Eliminer le code mort

Retire le code superflu. Cliquez sur la flèche vers le bas pour effectuer une sélection à partir des valeurs possibles (True, False). Valeur par défaut = False

Eliminer les expressions dupliquées au sein des blocs et fonctions de base

Indique au compilateur d'éliminer les sous-expressions communes dans les groupes d'instructions non interrompues par des branchements (blocs de bases) et les fonctions. Cette option élimine globalement les expressions dupliquées dans la portée cible et stocke une seule fois la valeur calculée de ces expressions (au lieu de les recalculer). Utilisez cette option si vous préférez réutiliser des expressions plutôt que de leur créer des emplacements explicites dans la pile. Valeur par défaut = False

Activer la réduction de force et de variable d'induction de boucle

Indique au compilateur de créer des variables d'induction et d'effectuer une réduction de puissance pour optimiser la vitesse d'exécution des boucles. Utilisez cette option quand vous cherchez à optimiser la vitesse d'exécution de votre application et que votre code contient des boucles.

L'optimiseur fait appel à l'induction pour créer de nouvelles variables (variables d'induction) à partir des expressions utilisées dans les boucles. L'optimiseur s'assure que les opérations effectuées sur ces nouvelles variables sont plus performantes (de puissance réduite) que celles sur les variables originales.

Les optimisations sont systématiques si vous utilisez des indices de tableaux dans les boucles, car une opération de multiplication est nécessaire au calcul de la position dans le tableau indiquée par l'indice. Dans le code suivant, l'optimiseur crée une variable d'induction à partir de l'opération v[i] car l'opération v[i] exige une multiplication. Cette optimisation élimine aussi la nécessité de conserver la valeur de i :

int v[10];
void f(int x, int y, int z) 
{ int i;
  for (i = 0; i < 10; i++) 
    v[i] = x * y * z; 
}

Avec l'ensemble des variables d'induction, le code devient :

int v[10];
void f(int x, int y, int z) 
{ int i, *p;
  for (p = v; p < &v[9]; p++)
  *p = x * y * z; 
}

Valeur par défaut = False

Activer la programmation des instructions Pentium

Génère des instructions Pentium. Cette option augmente la vitesse d'exécution de l'application sur les machines Pentium. Mais le programme sera un peu plus volumineux que celui généré avec une option 80386 ou i486. D'autre part, le code compilé pour le Pentium maintient un haut niveau de performance sur les systèmes non Pentium. Valeur par défaut = False

Développer les fonctions intrinsèques communes

Indique au compilateur de générer le code des fonctions mémoire communes, comme strcpy() dans la portée de votre fonction. Cela élimine le besoin d'un appel de fonction. Le code résultant s'exécute plus rapidement, mais il est aussi plus volumineux. Les fonctions suivantes sont développées avec cette option :

alloca, fabs, memchr, memcmp, memcpy, memset, rotl, rotr, stpcpy, strcat, strchr, strcmp, strcpy, strlen, strncat, strncmp, strncpy, strnset, strrchr.

Vous pouvez contrôler le développement de ces fonctions avec la directive pragma intrinsic. Par exemple,

#pragma intrinsic strcpy

force le compilateur à générer le code inline de tous les appels ultérieurs à strcpy dans votre fonction, et

#pragma intrinsic -strcpy

empêche le compilateur de mettre en ligne strcpy. L'utilisation de ces pragmas dans un fichier redéfinit les options de compilation.
Valeur par défaut = False

Optimiser les sauts

Indique au compilateur de réduire la taille du code en éliminant les branchements redondants et en réorganisant les instructions de boucles et les instructions switch. Quand cette option est définie, les phases d'exécution pas à pas dans le débogueur peuvent être inintelligibles dans la mesure où certaines instructions sont réordonnées ou supprimées. Si vous déboguez au niveau assembleur, il est préférable de désactiver cette option. Valeur par défaut = False

Utiliser les variables registre

Indique au compilateur d'affecter automatiquement des variables registre quand cela est possible, même si vous ne spécifiez pas une variable registre en utilisant le mot clé register. Valeur par défaut = False

YesC++11Feature.png
YesC++11Feature.png

Générer du code le plus rapide possible

Ce commutateur définit un groupe d'options d'optimisation qui demande au compilateur d'optimiser votre code pour la vitesse. Cette option ou l'option Générer du code le plus petit possible doit avoir pour valeur True, et elles doivent être mutuellement exclusives. Valeur par défaut = False

YesC++11Feature.png
YesC++11Feature.png
YesC++11Feature.png
YesC++11Feature.png
YesC++11Feature.png
YesC++11Feature.png

Générer du code le plus petit possible

Définit un groupe d'options d'optimisation qui demande au compilateur d'optimiser votre code pour la taille. Par exemple, le compilateur recherche dans le code généré les séquences répétées. Lorsqu'il en existe, l'optimiseur remplace une des séquences de code par un branchement sur l'autre et élimine le premier fragment de code. Cela se produit plus souvent avec les instructions switch. Le compilateur optimise pour la taille en choisissant la séquence de code la plus petite possible. Cette option ou l'option Générer du code le plus rapide possible doit avoir pour valeur True, et elles doivent être mutuellement exclusives. Valeur par défaut = False

YesC++11Feature.png
YesC++11Feature.png
YesC++11Feature.png
YesC++11Feature.png
YesC++11Feature.png
YesC++11Feature.png

Voir aussi