Opttimisation de l'application

Introduction

Il existe plusieurs langages de programmations. Parmi ceux-ci, nous avons préféré de parler de l?optimisation du langage Visual Basic 6.0.

Visual Basic est une variante du BASIC (Beginners All purposes Symbolic Interchange Code) conçu uniquement pour faciliter l?apprentissage de la programmation. Ce langage est le plus populaire des langages de programmations.

Visual basic est un langage le plus répondus parce qu?il est installé avec ou intégré dans tous les systèmes d?exploitations depuis les origines.

Avec l?arrivée de Windows, l?intégration des interfaces graphiques de Windows dans Basic a donné naissance à Visual basic. Héritant de la popularité de BASIC, Visual Basic est devenu le premier langage de programmation pour PC (Personal Computer).

Il a atteint son plus haut niveau avec l?arrivée de l?environnement de données et des API de connexion du genre ADO. C?est pouquoi notre étude portera sur ceux-ci pour montrer les aspects possibles pour l?optimisation.

44

Chapitre I: Optimisation des variables 1-Déclarations des variables

La déclaration du type de variable est une première optimisation extrêmement classique et indispensable. Afin de n'oublier aucune déclaration, utiliser en tête de module ou de Form etc... la fonction :

Option Explicit

Succinctement, à retenir pour choisir le type :

· Pour des nb entier utilisez de préférence le type Long.

· Pour des nb décimaux utilisez nécessairement le type Double.

· Pour des variables de chaînes utilisez le type String.

Bien sur, les déclarations dépendent aussi des besoins.

Mais d?une manière générale, l?emploi du type Variant (autre que dans les appels de fonctions) n'est jamais indispensable, et est à proscrire pour l?optimisation. Ce type est surtout intéressant pour faciliter la programmation aux débutants. Mais cette facilité se paye par une baisse importante des performances.

Une de remarque syntaxique.

Certains pensent que : " Dim a, b, c As Long" déclare les 3 variables en Long. Seul "c" est ici en Long, "a" et "b" sont déclarées en Variant, par défaut. La syntaxe correcte est : " Dim a As Long, b As Long, c As Long"

2-Utilisation des tableaux (Dim)

Quelques évidences. L?optimisation avec les tableaux, consiste d?abord à déclarer son type. Puis, autant que possible, il faut trouver une " structure " et/ou déterminer le nombre d?éléments, quitte à définir un nombre en excès, afin de ne jamais manipuler une nouvelle fois la déclaration d?un tableau ; par exemple, évitez de réutiliser Redim (Preserve).

L?utilisation d?une variable "tableau" est toujours moins rapide qu?une variable "simple" de type équivalent. Cette caractéristique est générale. La durée est au moins doublée. Donc, n?utilisez pas une variable "tableau" dans des instructions spécifiques, comme par exemple dans une boucle FOR avec FOR M(0)=...etc.

Chapitre II: Optimisation sur les nombres 1-Longueur d'un nombre entier positif ou nul.

Pour connaître le nombre de chiffre.

Forme optimisée :

Fix(Log(nb + 0.11) ! Log(10)) + 1

Ici 0.11 est utile dans le cas ou nb=0, ainsi la formule renvoi 1. Si nb ne peut pas être nul, retirer cette constante.

Forme équivalente : (+3.9*) Len(Str$(nb)) - 1

Forme équivalente : (+5*) Len(Trim$(Str$(nb)))

Programme de test :

temps = Timer

Dim nb As Long, lg As Long

For nb = 1 To 100000

lg = Fix(Log(nb + 0.11) ! Log(10)) + 1 ' par formule math 'lg = Len(Str$(nb)) - 1 ' chaîne

'lg = Len(Trim$(Str$(nb))) 'par fonction de chaîne Next nb

MsgBox Timer - temps

2-Pour un nombre entier négatif

A partir de la forme précédente, il faut adapter la programmation et on rajoutera +1 pour tenir compte du signe négatif ou +1 pour la virgule.

Forme optimisée :

Fix(Log(Abs(nb) + 0.11) ! Log(10)) + 2

Forme équivalente : Len(Str$(nb))

etc...

46

3-Parité d?un nombre

Pour tester si un nombre est pair :

Forme optimisée :

If (nb And 1) = 0 Then ...

Forme équivalente : (+1.2*) If nb Mod 2 = 0 Then ...

Forme équivalente : (+1.3*) If nb = 2 * (nb \ 2) Then ...

Forme équivalente : (+2.1*) If nb = 2 * Int(nb / 2) Then ...

Forme équivalente : (+2.7*) If nb / 2 = Int(nb / 2) Then ...

Programme de test :

temps = Timer

Dim nb As Long, lg As Long

For nb = 0 To 10000000

If (nb And 1) = 0 Then lg = lg + 1 'If nb Mod 2 = 0 Then lg = lg + 1

'If nb = 2 * (nb \ 2) Then lg = lg + 1

'If nb = 2 * Int(nb / 2) Then lg = lg + 1 'If nb / 2 = Int(b / 2) Then lg = lg + 1 Next nb

MsgBox Timer - temps

Pour tester si un nombre est impair :

Forme optimisée :

If (nb And 1) Then ...

Remarque : Entre les deux formes optimisées, cette dernière est plus rapide car il n?y a pas de test d?égalité (=0) prenant du temps dans le traitement. (pair : +1.1*)

4-Calculs des puissances entières

Curieuse fonction que " ^ " qui s?effectue en un temps quasi-constant quelle que soit la puissance, mais reste moins rapide que la multiplication successive jusqu?à puissance 9 environ.

Forme optimisée : nb = lg * lg * ... * lg

48

Forme équivalente : nb = lg " 2 (+7.5*) nb = lg " 3 (+5.0*) nb = lg " 4 (+4.6*) nb = lg " 5 (+3.9*)

Programme de test :

temps = Timer

Dim nb As Long, lg As Long, A As Long lg = 100

For A = 0 To 10000000

nb = lg * lg

'nb = 100 * 100

'nb = lg " 2

Next A

MsgBox Timer - temps

5-Calcul de la racine carré

Forme optimisée : lg = Sqr(nb)

Forme équivalente : (+3.5*) lg = nb " 0.5

Programme de test :

temps = Timer

Dim nb As Long, lg As Double For nb = 1 To 10000000

lg = Sqr(nb)

'lg = nb " 0.5

Next nb

MsgBox Timer - temps

Remarque : comme pour les puissances, on peut cumuler les racines carrés optimisées jusqu?à 4. Ainsi lg = Sqr(Sqr(Sqr(Sqr(nb)))) est la dernière expression plus rapide que lg = nb " 0.0625.

6-Division entière

Dans le cas oil les nombres peuvent être déclarés en type Long sans dépassement de capacité.

Forme optimisée : nb = nb1 \ nb2

Forme équivalente : (+2.3*) Nb = Int(nb1 / nb2)

Programme de test :

temps = Timer

Dim nb As Long, lg As Long For nb = 1 To 10000000

lg = 1000000 \ nb

'lg = Int(1000000 / nb)

Next nb

MsgBox Timer - temps

7-La multiplication plus rapide que la division

Dans une expression mathématique, il est légèrement plus rapide d'effectuer une multiplication par l'inverse d'un nombre que de diviser par ce même nombre. Ainsi, par exemple, pour diviser par 4, au lieu de faire (expression)/4, faire 0.25*(expression).

Forme optimisée :

nb = nb1 * [inverse nb2]

Forme équivalente : (+1.1*) Nb = nb1 / nb2

Programme de test :

temps = Timer

Dim nb As Double, lg As Double For nb = 1 To 10000000

lg = nb * 0.25

'lg = nb / 4

Next nb

MsgBox Timer - temps

8-Le Pré-calcul

Dans une boucle, il faut sortir tous les calculs d?expression constante.

Forme optimisée :

Dim nb As Long, lg As Double, z As Double z = Sqr(2)

lg = nb * z

Forme équivalente : (+2.7*) lg = nb * sqr(2)

Programme de test :

temps = Timer

Dim nb As Long, lg As Double, z As Double z = Sqr(2)

For nb = 1 To 10000000 lg = nb * z

'lg = nb * Sqr(2)

Next nb

MsgBox Timer - temps

9-Maximum et Minimum de 2 nombres

Forme optimisée :

If a < b Then max = b Else max = a

Forme équivalente : (+1.5*) max = (a+b+abs(a-b))/2 min = (a+b-abs(a-b))/2

Forme équivalente : (+4.3*)

max = IIf(a < b, b, a) min = IIf(a < b, a, b)

Programme de test : temps = Timer

Dim a As Long, b As Long, max As Long, c As Long

a = 3: b = 5

For t = 1 To 1000000

If a < b Then max = b Else max = a

'max = (a + b + Abs(a - b)) / 2

'max = IIf(a < b, b, a)

c = a: b = a: a = c Next t

MsgBox Timer - temps

10-Attribution de 2 valeurs alternatives

On rencontre assez souvent en programmation des variables utilisées comme indicateurs « flags » pouvant prendre que deux valeurs. On peut évidemment utiliser le type Booléan dans ce cas, avec TRUE et FALSE. Mais est-ce le meilleur ? La réponse est positive. Or, ce n?est pas toujours ce choix qui est fait.

Forme optimisée :

a = True

b = False

Forme équivalente : (+1.2*)

a = -1

b = 0

Programme de test : temps = Timer

50

Dim t As Long, maxi As Long maxi = 10000000

ReDim b(maxi) As Boolean 'ReDim b(maxi) As Byte

For t = 0 To maxi

b(t) = False

'b(t) = 0

Next t

MsgBox Timer - temps

On observe également sur ce test qu?il est aussi préférable d?utiliser le type Boolean au lieu de Byte même si ces deux types sont codés sur 8 bits chacun.

Chapitre III : Optimisation des tests

1-Vérification d?une condition avec renvoi Booléan

Forme optimisée :

a=(condition)

Ici condition pourrait être constituée par une expression comme b=c, soit a=(b=c). L?interprétation est facile, si b=c alors VB remplace en interne cette condition par la valeur vraie (True), puis l?affecte à "a", soit a=True. Même chose dans le cas contraire, avec False. Cette optimisation est valable que pour le renvoi d?une valeur Booléan.

Forme équivalente : (+1.5*)

If condition Then a = True Else a = False

Programme de test :

temps = Timer

Dim nb As Long, a As Boolean

For nb = 1 To 10000000

a = (nb And 1)

'If (nb And 1) Then a = True Else a = False Next nb

MsgBox Timer - temps

2-Les fonctions conditionnelles

Au vu des très nombreuses formes qu'on peut imaginer pour utiliser les fonctions conditionnelles, nous les présentons au fur et à mesure, sans être exhaustif.

Dans une série de tests conditionnels et quel que soit le nombre de condition et la complexité des conditions, " If... Then... ElseIf... End If " est le plus performant. Mais il faut savoir aussi regarder le côté pratique du codage, ce qui privilégie sans doute Select Case. De plus, on s?efforcera de mettre la condition qui a le plus de chance d?être vérifiée en premier pour sortir du test le plus tôt possible.

Forme optimisée : If (condition1) Then

(instructions1)

ElseIf (condition2) Then

(instructions2) ElseIf ...

End If

52

Forme équivalente : (+1.1*)

If (condition1) Then (instructions1)
If (condition2) Then (instructions2)

Forme équivalente : (+1.2*)

Select Case (variable)

Case (condition1) (instructions1)

Case (condition2) (instructions2)

...

End Select

Forme équivalente : (+1.25*)

If (condition1) Then (instructions1)

Else

If (condition2) Then (instructions2)

Else

...

End If

End If

Programme de test :

temps = Timer

Dim t As Long, j As Long, a As Long For j = 1 To 1000000

For t = 1 To 5

If t = 1 Then

a = a + 1

ElseIf t = 2 Then

a = a + 2

ElseIf t = 3 Then

a = a + 3

ElseIf t = 4 Then

a = a + 4

ElseIf t = 5 Then

a = a + 5 End If

Next t, j

MsgBox Timer - temps

Programme de test : temps = Timer

Dim t As Long, j As Long, a As Long For j = 1 To 1000000

For t = 1 To 5

If t = 1 Then a = a + 1 If t = 2 Then a = a + 2 If t = 3 Then a = a + 3 If t = 4 Then a = a + 4 If t = 5 Then a = a + 5 Next t, j

MsgBox Timer - temps

Programme de test :

temps = Timer

Dim t As Long, j As Long, a As Long For j = 1 To 1000000

For t = 1 To 5

Select Case t

Case 1

a = a + 1 Case 2

a = a + 2 Case 3

a = a + 3 Case 4

a = a + 4 Case 5

a = a + 5 End Select

Next t, j

MsgBox Timer - temps

Programme de test :

temps = Timer

Dim t As Long, j As Long, a As Long For j = 1 To 1000000

For t = 1 To 5 If t = 1 Then a = a + 1

Else

If t = 2 Then a = a + 2

Else

If t = 3 Then a = a + 3

Else

If t = 4 Then a = a + 4

Else

If t = 5 Then a = a + 5

End If

54

End If End If End If End If Next t, j

MsgBox Timer - temps

On pourrait encore se poser la question dans le cas d?une série de conditions rassemblées avec un opérateur logique, par exemple avec OR. La structure " If... Then... ElseIf... End If " pourrait toujours être utilisée et resterait la plus rapide, mais serait très lourde à écrire, puisqu'il faudrait répéter de très nombreuses fois les mêmes instructions...

Forme optimisée : Voir ci-dessus.

Programme de test : (+1.25*)

temps = Timer

Dim t As Long, j As Long, a As Long

For j = 1 To 1000000

For t = 1 To 5 Select Case t Case 1, 2, 5 a = a + 1

Case 3, 4

a = a + 3

End Select

Next t

Next j

MsgBox Timer - temps

Programme de test : (+1.25*)

temps = Timer

Dim t As Long, j As Long, a As Long

For j = 1 To 1000000

For t = 1 To 5

If t = 1 Or t = 2 Or t = 5 Then

a = a + 1

ElseIf t = 3 Or t = 4 Then

a = a + 3

End If Next t Next j MsgBox Timer - temps

3-Les différentes écritures de If

En VB, les différentes formes d'écriture de l'instruction "IF" ont une influence sur la vitesse d'exécution, mais la différence n'existe pas après compilation.

Forme optimisée :

If (condition) Then (instructions1) Else (instructions2)

Forme équivalente : (+1.1*)

If (condition) Then (instructions1) Else: (instructions2)

Forme équivalente : (+1.3*)

If (condition) Then

(instructions1) Else

(instructions2) End If

Programme de test :

temps = Timer

Dim a As Long, b As Long, max As Long, c As Long a = 3: b = 5

For t = 1 To 10000000

If a < b Then max = b Else max = a

'If a < b Then max = b Else: max = a

'If a < b Then

' max = b

'Else

' max = a

'End If

c = a: b = a: a = c

Next t

MsgBox Timer - temps

56

Chapitre IV : Optimisation sur les chaînes 1-Les fonctions de chaînes

Certaines fonctions sur les chaînes existent en deux versions, correspondant soit à un type de données en Variant, soit en String déclaré par le signe dollar ($). Cette dernière version est la plus rapide. Par exemple, String deviendra String$.

Les fonctions concernées sont :

Chr$, ChrB$, CurDir$, Date$, Dir$, Error$, Format$, Hex$, Input$, InputB$, LCase$, Left$, LeftB$, LTrim$, Mid$, MidB$, Oct$, Right$, RightB$, RTrim$, Space$, Str$, String$, Time$, Trim$, UCase$.

String$

L?appel à certaines de ces fonctions peut être plus optimisé, en déclarant les paramètres de l?instruction dans une variable adaptée. Utile seulement dans une boucle.

Forme optimisée :

Dim z As String, lg As String z = "0"

lg = String$(1000, z)

Forme équivalente : (+1.1*) String(1000, z)

Forme équivalente : (+1.1*) String$(1000, 48)

Forme équivalente : (+1.3*) String$(1000, "0")

Programme de test : temps = Timer

Dim nb As Long, z As String, lg As String

z = "0"

For nb = 1 To 1000000 lg = String$(1000, z) 'lg = String(1000, z) 'lg = String$(1000, 48)

'lg = String$(1000, "0") 'lg = String(1000, "0") Next nb

MsgBox Timer - temps

2-Chaîne statistique ou dynamique

La déclaration de chaîne peut être fait de deux manières, soit statistique (au maximum 63ko) en définissant une longueur fixe grâce à String * (longueur), soit dynamique (jusqu?à 2 milliards de caractère).

Curieusement la déclaration dynamique est nettement plus rapide pour la concaténation de chaîne.

Forme optimisée : Dim a As String

Forme équivalente : (+3*) Dim a As String * (nombre)

Programme de test :

temps = Timer

'Dim a As String * 7, b As String * 7, c As String * 14 Dim a As String, b As String, c As String

Dim t As Long

a = "bonjour"

b = " à toi!"

For t = 1 To 10000000

c = a & b

Next t

MsgBox Timer - temps

3-La concaténation de chaîne

La concaténation est identique avec " & " ou " + ". Préférer " & " pour éviter toute confusion.

Néanmoins, on peut faire une concaténation plus rapide, utile dans une boucle. Cela consiste à déclarer la variable de réception avec une taille valant (ou par excès), la taille des chaînes à concaténer, puis d?utiliser Mid$. Cette astuce semble également beaucoup plus performante sous les dernières versions de VB (version 6 ou plus).

Forme optimisée :

c = Space$(14)

Mid$(c, 1, 7) = a: Mid$(c, 8, 7) = b

Forme optimisée : (+1,04*)

Dim l1 As Long, l2 As Long, l3 As Long, c As String l1 = Len(a): l2 = Len(b): l3 = l1 + 1

c = Space$(la + lb)

Mid$(c, 1, l1) = a: Mid$(c, l3, l2) = b

58

Forme équivalente : (+1,5*) c = a & b

Forme équivalente : (+1,5*) c = a + b

Programme de test : temps = Timer

Dim a As String, b As String, c As String, t As Long

a = "bonjour"

b = " à toi!"

c = Space$(14)

'Dim l1 As Long, l2 As Long, l3 As Long

'l1 = Len(a): l2 = Len(b): l3 = l1 + 1

'c = Space$(l1 + l2) For t = 1 To 1000000

Mid$(c, 1, 7) = a: Mid$(c, 8, 7) = b

'Mid$(c, 1, l1) = a: Mid$(c, l3, l2) = b

'c = a & b

'c = a + b

Next t

MsgBox Timer - temps

4-La chaîne nulle

Pour attribuer une chaîne nulle à une variable utilisez la constante vbNullString.

Forme optimisée : mot = vbNullString

Forme équivalente : (+4*) mot = ""

Forme équivalente : (+5.5*) mot = Chr$(0)

Programme de test :

temps = Timer

Dim nb As Long, mot As String For nb = 1 To 1000000

mot = vbNullString

'mot = ""

'mot = Chr$(0)

Next nb

MsgBox Timer - temps

Chapitre V : Optimisation des boucles

La variable d?une boucle doit être déclarée pour être optimale. Option Explicit est donc très pratique ici...

Parmi toutes les syntaxes et conditions d?utilisation on peut faire un classement des boucles en fonction de leur rapidité d?exécution, pour réaliser exactement le même nombre de passages.

IL est à noter qu?on peut retenir uniquement deux formes de boucles optimales : FOR TO NEXT, dans le cas oil l'on connaît exactement les bornes, oil DO.. LOOP (UNTIL/WHILE) sinon.

For... To... (Step)... Next

La vitesse est la plus rapide pour le type Integer. A défaut, si la borne > 32766 alors prendre le type Long (presque équivalent).

Forme optimisée :

Dim Variable As Long, borne_fin As Long

borne_fin = (un nb ou une expression)

FOR Variable = (un nb ou une expression) TO borne_fin STEP (un nb ou une expression)

NEXT

Programme de test :

temps = Timer

Dim nb As Integer, nb2 As Integer 'Dim nb As Long, nb2 As Long 'Dim nb As Double, nb2 As Double For nb = 1 To 1000

For nb2 = 1 To 32766

Next nb2

Next nb

MsgBox Timer - temps

Do.. Loop (While/Until)

Do (While/Until)... Loop

Do.. Exit Do... Loop

While... Wend

étiquette... Goto étiquette ... Goto suite

Formes optimales et test : Dim A As Long

Do

A = A + 1

Loop Until A = 10000000

60

Forme équivalente et test : (+1.1*) Dim A As Long

Do

A = A + 1

Loop While A < 10000000

Forme équivalente et test : (+1.3*) Dim A As Long

Do Until A = 10000000

A = A + 1

Loop

Forme équivalente et test : (+1.4*) Dim A As Long

boucle:

A = A + 1

If A < 10000000 Then GoTo boucle

Forme équivalente et test : (+1.4*) Dim A As Long

Do While A < 10000000

A = A + 1

Loop

Forme équivalente et test : (1.5*) Dim A As Long

Do

A = A + 1

If A = 10000000 Then Exit Do Loop

Forme équivalente et test : (+1.5*) Dim A As Long

While A < 10000000

A = A + 1

Wend

Forme équivalente et test : (+1.9*) Dim A As Long, nb As Integer

For nb = 0 To 1

nb = 0

A = A + 1

If A = 10000000 Then Exit For Next

Forme équivalente et test : (+2.7*) ReDim A(0) As Long

Do

A(0) = A(0) + 1

Loop Until A(0) = 10000000

Pour exécuter une instruction une fois sur x passages :

Forme optimisée :

Dim Saut As Long, A As Long, nb As Long

Saut = 90

For nb = 0 To 10000000

If nb = Saut Then Saut = Saut + 90: A = A + 1 'instructions Next nb

Forme équivalente : (+1.9*)

Dim A As Long, nb As Long

For nb = 0 To 10000000

If nb mod 90 Then A = A + 1 'instructions Next nb

Programme de test : temps = Timer

Dim Saut As Long, A As Long, nb As Long

Saut = 90

For nb = 0 To 10000000

If nb = Saut Then Saut = Saut + 90: A = A + 1

'If nb Mod 90 Then A = A + 1 'instructions

Next nb

MsgBox Timer - temps

62

Chapitre VI : Compulation de l?application

Utiliser un programme en l'exécutant sous Vb, c'est bien, mais en compilé en .Exe, c?est plus mieux.

En effet, Vb fournit lors de la compilation un certain nombre de routines pour optimiser les performances de votre application, ces routines sont :

-L?IDE ;

-Le compulateur ; -API ;

-Recursivités.

1-IDE

Lorsqu?on exécute un programme sous l'ide de vb, celui-ci interprète ligne par ligne (bloc par bloc) le comportement de l'application en faisant une analyse de la syntaxe. Chaque méthode, chaque fonction, chaque instruction écrite appel dans msvbvm60.dll un "api" qui exécutera l'instruction lorsque le pointeur d'exécution (la "ligne jaune"...) sera dessus.

2-Le Compilateur

Pour executer le compilateur sous VB, vous devez aller dans le Menu Fichier &gt; créer Projet1.exe puis bouton "Options...", onglet "Compilation" Vous avez alors accès aux différentes options de compilations comme la fenêtre suivante l?indique :

a-Compilation P-Code

Les routines du programme sont transcrites en p-code. La compilation en p-code oblige l'utilisation d'un interpreteur de p-code puisqu'il ne s'agit pas d'asm compilé. Vous n'obtiendrez que peu de performances en utilisant cette méthode de compilation. En revanche, le p-code autorise des artefacts de programmation qui ne sont pas autorisés via la compilation en code natif, ce qui explique qu'un programme compilé en p-code est plus stable et peut être décompilé facilement.

b-Compilation en code natif

Les routines du programme sont interpretées puis compilées en binaire (asm compilé). Les performances des algoritmes sont donc maximales, car il n'y a plus d?interprétation.

Ici, il s'agit des "performances maximales" pour des routines compilées sous vb. Comme dit précédemment, les routines sont interprétées puis compilées définitivement. Le compilateur "code natif" permet d'agir sur la méthode d?interprétation ainsi que sur la méthode de compilation :

-optimiser la rapidité du code

L?interpréteur du compilateur simplifiera les structures vers un code commun "pré-optimisé" (par exemple, un "for... next" ou un "do... loop until" sera équivalent). Il y aura également une étude des algorithmes simple pour les "résumer" (par exemple : "do: i=i+1:loop while i &lt; 1000" sera remplaçé par "i =1000"...).Le code final sera donc potentiellement plus rapide car l'interprétation aura simplifié le code. Notez donc qu'il est possible de "manuellement" d?optimiser la rapidité du code, en programmant de la façon la plus simple qu'il soit, les routines classique (A ce sujet, voir mon précédent.

-Optimiser la taille du code

L?interpréteur du compilateur réduira la taille des structures pour obtenir un code binaire plus petit (mais pas obligatoirement le plus adapté). Il en résulte un .exe plus petit que s'il n'y a pas d'optimisation, mais parfois moins performant. La taille finale de l'exe sera entre 5% et 15% plus petit que sans optimisation (en arrondissant au multiple de 4096 octets, le gain est parfois de 0%). Il est difficile de réduire la taille du .exe compilé en réduisant manuellement la taille des algorithmes sous l'ide (sauf peut-être en supprimant tout ce qui est inutile : subs () jamais appelé, objets/classes inutile, etc...). Il existe un moyen plus astucieux pour réduire la taille du code compilé que d?utiliser cette option...

64

-Pas d?optimisation

L?interpréteur traduit "tout ce qu'il lit" en binaire sans restructurations particulière. De toutes évidences ce mode n'est pas interssant... sauf pour une comparaison avec les autres modes su-cités comparaison avec les autres modes.

Viennent ensuite deux options en complément :

-Favoriser le Pentium Pro

La compilation utilisera préférentiellement les instructions ASM fonctionnant rapidement dans les core Pentium Pro. On peut s'attendre à quelques performances supérieurs sur les "vieux" pentiums ou pentiums-2 et a des performances moindres sur les k6/cyrix/486... Mais sur les processeurs tels que PIII, PIV, Celeron ou K7, il n'y aura pas de différences.

-Générer des informations de débogager symbolique

Equivalent de la compilation "debug" de vc++, cela permet le débogage du programme compilé en utilisant des débogueurs compatibles CodeView (le débogueur de VC++ par exemple...). Cela interessera ceux qui ont l'habitude déboguer un programme compilé (les codeurs c/c++ ...). Malheureusement, nous ne savons pas quels débogages supplémentaires sont accessibles via cette méthode, par rapport à ce qui est possible sous l?ide.

c-Optimisation avancéés

Vous avez accès à des options supplémentaires. En cochant judicieusement sur les cases là oil c'est nécessaire, vous pouvez gagner instantanément 30% de vitesse d'exécution, en plus de l'option "Optimiser la rapidité du code" ! Mais, vous pouvez aussi réduire les performances, voire même provoquer des erreurs non gérées par « On Error ».

Pour les performances optimales, vous ne devrez cocher que les cases nécessaires. En lisant la description ci-dessous, identifiez si vos routines seront optimisées ou non via l?option choisie.

-Pas d?utilisation d?alias :

Optimise le stockage des variables en mémoire, lorsque les références sont communes. Lorsque vous utilisez des arguments ByRef pour appeler des subs (), la compilation binaire plaçera astucieusement en cache les variables régulièrement appelées, comme c'est le cas dans les boucles (do: call T(i): i=i+1: loop until i &gt; 1000 ; avec Sub T (i as long)). Cette optimisation est interessante si votre code appelle souvent les mêmes variables partagées dans beaucoup de sous-fonctions. Dans le cas contraire (le plus probable), la "mise

en cache" forcé des variables seront des intructions superflues et vous risquez de perdre des performances.

-Supprimer les contrôles de limites de tableaux Prenons un exemple:

"dim Tb(1 to 1000) as long

for i = 1 to 1000: Tb(i) = i*2

Next".

Lorsque le code est compilé, avant l'instruction "Tb(i) =" il y a un test pour savoir si "i &gt; 1000" et si c'est le cas, le programme appelle __vbaGenerateBoundsError, générant une erreur pouvant être intercepté via "On Error...", pour éviter le "seg fault" (tentative d'accès à une zone mémoire non alloué/autorisé). Si on ne coche pas cette case, cela reviendrai à faire un "If i &gt; UBound(tabl()) Then Err.Raise" avant chaque appel dans un tableau!! (Collection d'objets inclus). En enfin, si votre programme utilise un tableau, et si vous ne risquez pas de "dépasser" ce tableau, cochez cette case! Y gagnerez assurément en performances!

-Supprimer les contrôles de dépassement sur les entiers

A chaque calcul aboutissant dans un entier, il y a une étape pour vérifier si l'entier ne dépasse pas la valeur maximale autorisée dans son type (+32767 dans le cas de l?Integer). S'il y a dépassement, le programme génère une erreur pouvant être interceptée par "On Error...". A l'instar de l'option précédente, en cochant cette case vous gagnerez immédiatement en performances puisque il y aura moins de tests. En revanche, si votre programme risque de faire un dépassement, attendez-vous à une inversion de signe dans les résultats! Exemple :

Dim i as integer

i = 32767 + 1" l'ide génère une erreur, tandis que le code compilé admettra i=-1.

-Supprimer les controles en virgule flottante

Equivalent de l'option précédente, mais sur les type Single et Double. Si une opération arithmétique dépasse la limite autorisée pour un type de données, le compilateur appelle le générateur d'erreur __vbaErrorOverflow, pouvant être intercepté par "On Error...". Cochez cette case si vous êtes sûr de ne pas faire un tel dépassement pour supprimer les quelques instructions de tests, et ainsi gagner en performances. S'il y a une erreur de ce type durant l'exécution alors

66

que le programme a été compilé avec cette option, le résultat du calcul sera faussé.

-Autoser les apérations en virgule flottante non arrondies

Si vous manipuler des chiffres à virgules flottantes dans les opérations arithmétique (type Single ou Double), par défaut vb ajuste en permanence le type pour qu'il y ai correspondance dans, par exemple, les comparaisons (dim s as single, d as double: : if s = d then ; dans cet exemple, d aura été converti en type single pour réaliser la comparaison). En cochant cette case, vous supprimez cet ajustement automatique. Cette option est interessante si vous travaillez avec la même précision tout au long de vos routines (uniquement Single ou Double) : en effet la compilation binaire utilisera plus efficacement les registres mémoires et n'insérera pas d'instruction d'ajustement des "virgules".

-Supprimer les contrôles safe Pentium FDIV

Une génération de pentium (ceux compris entre 75MHz et 133Mhz) renvoyait un résultat légèrement faux lors de la division de deux chiffres à virgule flottante (instruction asm FDIV). Pour palier le problème, le compilateur intègre un correcteur automatique après chaque division en virugle flottante dans le code. Si votre programme réalise des divisions de ce type et que vous n'avez pas l'intention de l'utiliser sur un "vieux" pentium, cochez cette case pour supprimer ces tests et vous gagnerez quelques peux en performances.

Pour résumer ce qui vient d?être dit, nous dissons que les applications lorsqu?elles sont compilées permettent de juger de leurs vitesses d?exécutions, après que le concepteur ait pensé aux optimisations avancés et a coché les options comme code natif, rapidité du code, suppression des contrôles.

3-Les APIs

Utiliser des APIs extérieurs à vb permet à nos projets vb de voir leurs fonctionnalités très étendues. Or vous avez déjà pu lire qu?utiliser des APIs sous vb, c'est moins rapide que d'utiliser les fonctions préprogrammées vb. Je pense notamment aux manipulations de caractères. Par exemple : le petit "&" est l'équivalent de l'API lstrcat ()... normalement la vitesse d'exécution devrait être la même! Ais ce n?est pas le cas.

Parce que le '&' est intégré à vb". C'est un des éléments de réponse. L'autre élément à savoir est que vb n'appelle pas directement les API "déclarés" tel que le ferait un programme compilé. VB utilise une API qui appelle les API! Cette fonction que l'on appelle implicitement via "Declare" s'appelle DllFunctionCall. Et lorsque vous compilez votre programme vb en .exe , toutes les apis seront appelées via DllFunctionCall avec le nom "string" de l'API, le nom "string" de la dll, et un argument ParamArray.

Il faut comprendre qu?appeler une API sous vb sera définitivement toujours un peu plus lent que dans un autre langage.Cela ne signifie pas qu'il ne faut plus utiliser d'apis, mais qu'il faut les utiliser astucieusement. Car un .exe vb compilé, le programme appelle les fonctions le l'objet activex via __vbaObjSet (et quelques autres)..., si l'activex utilise beaucoup d?API brute, il est plus intéressant de passer via l'activex (un objet dans un fichier dont l'extension est soit .dll, soit .ocx). En revanche, si l'activex a été créé sous vb, ou que l'activex n'utilise pas plus d'API que l'on peut soi-même appelé via "Declare", utilisez directement les API ! C'est plus rapide. A noter que, pour justement palier à ce problème, directx/direct3d8 intègre directement ses APIs dans le .exe Vb compilé.

Utiliser un activex est toujours plus pratique pour la lisibilité d'un code. Si votre objectif est de faire un "bon code de démonstration", utilisez toujours ces activex! En revanche, si vous souhaitez des performances, oubliez les règles standard de coding : trichez, imbriquez, outrepassez et detournez les fonctions vb!

4-Recursivité

Chaque fois que vous appelez une de vos fonctions (par l?instruction Call) utilisateur, ou qu'il y a un appel à un "evênement", etc... Sachez que dans le .exe vb compilé, il y a toujours une vérification de la "pile d'instruction" via __vbaChkStk (on peut l'assimiler aux nombres de sous-sous-sous-subs () dans lequel le pointeur "ligne jaune" se situe). Cela permet de générer l'erreur "Espace de pile insuffisant". Comprenez donc que plus vous appelez de subs et de sous-subs, plus l?exécution ne perdra des performances pour faire cette vérification.