Optimiser votre code
Le Turbo Pascal effectue plusieurs types d'optimisations de code, allant de valeur constante et de l'évaluation des expressions booléennes en court-circuit, jusqu'à la liaison intelligente. Les pages suivantes décrivent certains des types d'optimisations effectuées et comment vous pouvez en tirer parti dans vos programmes.
Valeur constante
Si le ou les opérandes d'un opérateur sont des constantes, le Turbo Pascal évalue l'expression au moment de la compilation. Par exemple :
X := 3 + 4 * 2;
génère le même code que X - 11, et :
S := 'In' + 'Out';
génère le même code que S := 'InOut'. De même, si un opérande d'un appel de fonction Abs, Chr, Hi, Length, Lo, Odd, Ord, Pred, Ptr, Round, Succ, Swap ou Trunc est une constante, la fonction est évaluée au moment de la compilation. Si une expression d'index de tableau est une constante, l'adresse du composante est évaluée au moment de la compilation. Par exemple, accéder à Data[5, 5] est tout aussi efficace que d'accéder à une simple variable.
Fusion constante
L'utilisation de la même constante de chaîne de caractères deux fois ou plus dans une partie d'instruction génère une seule copie de la constante. Par exemple, deux ou plusieurs instructions Write('Done') dans la même partie d'instruction font référence à la même copie de la constante de chaîne de caractères 'Done'.
Évaluation des courts-circuits
Le Turbo Pascal implémente une évaluation booléenne en court-circuit, ce qui signifie que l'évaluation d'une expression booléenne s'arrête dès que le résultat de l'expression entière devient évident. Il garantit un temps d'exécution minimum et généralement une taille de code minimale. L'évaluation en court-circuit rend également possible l'évaluation de constructions qui, autrement, ne seraient pas légales. Par exemple :
While(I <= Length(S)) and (S[I] <> ' ') do Inc(I);
while (P <> NIL) and (P^.Value <> 5) do P:=P^.Next;
Dans les deux cas, le deuxième test n'est pas évalué si le premier test est False. Le contraire de l'évaluation des courts-circuits est l'évaluation complète, étant sélectionnée via une directive de compilateur {$B+}. Dans cet état, chaque opérande d'une expression booléenne est garanti pour être évalué.
Paramètres constants
Dans la mesure du possible, vous devez utiliser des paramètres constants au lieu de paramètres de valeur. Les paramètres constants sont au moins aussi efficaces que les paramètres de valeur et, dans de nombreux cas, plus efficaces. En particulier, les paramètres constants génèrent moins de code et s'exécutent plus rapidement que les paramètres de valeur pour les types structurés et chaîne de caractères. Les paramètres constants sont plus efficaces que les paramètres de valeur car le compilateur n'a pas à générer de copies des paramètres réels lors de l'entrée dans des procédures ou des fonctions. Les paramètres de valeur doivent être copiés dans des variables locales afin que les modifications apportées aux paramètres formels ne modifient pas les paramètres réels. Comme les paramètres formels constant ne peuvent pas être modifiés, le compilateur n'a pas besoin de générer des copies des paramètres réels, et le code et l'espace de pile sont enregistrés.
Élimination redondante de la charge de pointeur
Dans certaines situations, le générateur de code de Turbo Pascal peut éliminer les instructions de chargement de pointeur redondantes, réduisant la taille du code et permettant une exécution plus rapide. Lorsque le générateur de code peut garantir qu'un pointeur particulier reste constant sur un tronçon de code linéaire (code sans saut), et lorsque ce pointeur est déjà chargé dans une paire de registres (comme ES:DI), le générateur de code élimine instructions de chargement de pointeur redondantes supplémentaires dans ce bloc de code. Un pointeur est considéré comme constant s'il est obtenu à partir d'un paramètre de variable (les paramètres de variable sont toujours passés sous forme de pointeurs) ou de la référence de variable d'une instruction WITH. Pour cette raison, l'utilisation d'instructions WITH est souvent plus efficace (mais jamais moins efficace) que l'écriture de la variable pleinement qualifiée pour chaque référence de composante.
Constante d'ensemble en ligne
Lorsque l'opérande droit de l'opérateur IN est une constante définie, le compilateur génère le test d'inclusion à l'aide d'instructions CMP en ligne. Ces tests intégrés sont plus efficaces que le code étant généré par une expression booléenne correspondante à l'aide d'opérateurs relationnels. Par exemple, cette déclaration :
If((Ch >= 'A') and (Ch <= 'Z')) or ((Ch >= 'a') and (Ch <= 'z'))Then ...
est moins lisible et aussi moins efficace que cela :
If Ch in ['A'..' Z', 'a'..'z'] Then ... ;
Étant donné que la déclaration constante s'applique aux constantes d'ensemble ainsi qu'aux constantes d'autres types, il est possible d'utiliser des déclarations CONST sans aucune perte d'efficacité :
Const
Upper = ['A'..'Z'];
Lower = ['a'..'z'];
Alpha = Upper + Lower;
Compte tenu de ces déclarations, cette instruction IF génère le même code que l'instruction IF précédente :
If Ch in Alpha Then { ... }
Petits ensembles
Le compilateur génère du code très efficace pour les opérations sur de petits ensembles. Un petit ensemble est un ensemble avec une valeur ordinale de limite inférieure comprise entre 0 et 7 et une valeur ordinale de borne supérieure comprise entre 0 et 15. Par exemple, TByteSet et TWordSet suivants sont tous deux de petits ensembles.
Type
TByteSet = Set of 0..7;
TWordSet = set of 0..15;
Les opérations de petits ensembles, telles que les tests d'union (+), de différence (-), d'intersection (*) et d'inclusion (IN) sont générées en ligne à l'aide d'instructions de code machine AND, OR, NOT et TEST au lieu d'appels aux routines de la bibliothèque d'exécution. De même, les procédures standard d'inclusion et d'exclusion génèrent du code en ligne lorsqu'elles sont appliquées à de petits ensembles.
Ordre d'évaluation
Comme le permettent les standards Pascal, les opérandes d'une expression sont fréquemment évalués différemment de l'ordre de gauche à droite dans lequel ils sont écrits. Par exemple, l'instruction :
I := F[J] div G[J];
où F et G sont des fonctions de type Integer, provoque l'évaluation de G avant F, car cela permet au compilateur de produire un meilleur code. Pour cette raison, il est important qu'une expression ne dépende jamais d'un ordre d'évaluation spécifique des fonctions intégrées. En vous référant à l'exemple précédent, si F doit être appelé avant G, utilisez une variable temporaire :
T := F[J];
I := T div G[J];
Il existe une exception à cette règle, lorsque l'évaluation des courts-circuits est activée (état {$B-}), les opérandes booléens regroupés avec AND ou OR sont toujours évalués de gauche à droite.
Vérification de la portée
L'affectation d'une constante à une variable et l'utilisation d'une constante comme paramètre de valeur est vérifiée par intervalle au moment de la compilation; aucun code de vérification d'intervalle d'exécution n'est généré. Par exemple, X := 999, où X est de type Byte, provoque une erreur de compilation.
Décaler au lieu de multiplier ou de diviser
L'opération X * C, où C est une constante et une puissance de 2, est codée à l'aide d'une instruction SHL. L'opération X div C, où X est un entier non signé (octet ou mot) et C est une constante et une puissance de 2, est codée à l'aide d'une instruction SHR. De même, lorsque la taille des composantes d'un tableau est une puissance de 2, une instruction SHL (et non une instruction MUL) est utilisée pour mettre à l'échelle l'expression d'index.
Alignement automatique des mots
Par défaut, Turbo Pascal aligne toutes les variables et les constantes typées supérieures à 1 octet sur une limite de mot machine. Sur tous les microprocesseurs 16 bits 80x86, l'alignement des mots signifie une exécution plus rapide, car les éléments de la taille d'un mot sur des adresses paires sont accessibles plus rapidement que les mots sur des adresses impaires. L'alignement des données est contrôlé via la directive du compilateur $A. Dans l'état {$A+} par défaut, les variables et les constantes typées sont alignées comme décrit ci-dessus. Dans l'état {$A-}, aucune mesure d'alignement n'est prise.
Éliminer le code mort
Les instructions ne s'exécutant jamais ne génèrent aucun code. Par exemple, ces constructions ne génèrent aucun code :
If False Then statement
While False do statement
Liaison intelligente
L'éditeur de liens intégré de Turbo Pascal supprime automatiquement le code et les données inutilisés lors de la création d'un fichier .EXE. Les procédures, fonctions, variables et constantes typées faisant partie de la compilation, mais n'étant jamais référencées, sont supprimées du fichier .EXE. La suppression du code inutilisé a lieu sur une base par procédure; la suppression des données inutilisées a lieu sur une base par section de déclaration. Considérez le programme suivant :
Le programme principal appelle P3, appelant P2, donc P2 et P3 sont inclus dans le fichier .EXE. Étant donné que P2 fait référence à la première section de déclaration var et que P3 fait référence à la deuxième déclaration VAR I, J, X, Y et S sont également inclus dans le fichier .EXE. Cependant, aucune référence n'est faite à P1 et aucune des procédures incluses ne fait référence à H et A, de sorte que ces objets sont supprimés. La liaison intelligente est particulièrement utile en relation avec les unités mettant en oeuvre des bibliothèques de procédures et de fonctions. Un exemple d'une telle unité est l'unité standard DOS : elle contient un certain nombre de procédures et de fonctions, étant toutes rarement utilisées par le même programme. Si un programme utilise uniquement une ou deux procédures de DOS, seules ces procédures sont incluses dans le fichier .EXE final et les autres sont supprimées, ce qui réduit considérablement la taille du fichier .EXE.