Temps d'exécution
La première chose qu'il est intéressant de pouvoir faire, c'est d'évaluer le temps d'exécution d'un programme. Ce qu'il faut donc mesurer, c'est la quantité de temps qui s'est écoulée entre le démarrage du programme et la fin de son exécution.
Outil du système d'exploitation
Une première possibilité pour mesurer le temps d'exécution d'un programme consiste à utiliser des outils de votre système d'exploitation en lançant le programme en ligne de commande. Sous Linux et macOS, on peut utiliser la commande time avec le programme à mesurer :
> time python3 fib.py python3 fib.py 0,08s user 0,01s system 91% cpu 0,098 total
Ce résultat montre que le programme fib.py a pris 0,08 s de temps utilisateur pour s'exécuter. Cela signifie qu'entre le moment où le programme a été lancé dans le terminal et le moment où il s'est terminé, 0,08 s se sont écoulées. On peut également voir que le programme n'a pris que 0,01 s de temps système. Il existe en effet différents types de temps, comme détaillé plus loin à la section 3.3.
Sous Windows, on peut utiliser la commande Measure-Command de l'interpréteur de commande de l'outil Windows Powershell :
> Measure-Command { python fib.py }
Days : 0
Hours : 0
Minutes : 0
Seconds : 0
Milliseconds : 71
Ticks : 712543
TotalDays : 8,24702546296296E-07
TotalHours : 1,97928611111111E-05
TotalMinutes : 0,00118757166666667
TotalSeconds : 0,0712543
TotalMilliseconds : 71,2543
Avec cette commande sous Windows, seul le temps utilisateur est renseigné dans le résultat, et dans plusieurs unités différentes. On a un temps d'exécution de 0,07 s, valeur similaire à celle obtenue précédemment.
Ces techniques sont évidemment limitées à la mesure du temps d'exécution d'un programme complet. De plus, elles prennent aussi en compte le temps de démarrage de la machine virtuelle Python.
Chronomètre manuel avec Python
Une autre possibilité pour mesurer le temps d'exécution consiste à le faire directement depuis le programme, en Python. Cette façon de faire est même nécessaire si l'on veut mesurer le temps d'exécution d'une partie de programme seulement. La façon la plus simple consiste à utiliser la fonction time du module time. Cette dernière renvoie le nombre de secondes écoulées depuis le 1er janvier 1970 (pour les systèmes UNIX, le 1er janvier 1970 00:00:00 (UTC), appelé epoch, correspond au moment où le temps commence) et, en capturant cette valeur avant et après l'exécution d'une partie de programme, on va pouvoir connaitre le temps qu'elle a pris pour s'exécuter.
Mesurons, par exemple, le temps que prend l'exécution de fib(25) (la définition de la fonction fib utilisée est celle donnée à la section 2.6), grâce au code suivant où start et end figent des instants dans le temps :
Un problème avec cette méthode est que l'on ne mesure le temps d'exécution d'une partie de programme qu'une seule fois. Si on relance plusieurs fois le programme, la valeur mesurée va fort probablement varier, notamment selon l'occupation de l'ordinateur. Voici le résultat d'une exécution de ce programme :
Temps d'exécution : 0.04ms
Ce problème se présente évidemment également avec la mesure faite avec les outils du système d'exploitation. Pour pallier ce problème, il faut répéter la mesure plusieurs fois et calculer une moyenne sur plusieurs exécutions. Ceci est plus facile à faire lorsque l'on réalise les mesures de temps directement en Python.
Voici une version modifiée du code de mesure qui va répéter la mesure du temps d'exécution $100$ fois et stocker tous les temps mesuré dans une liste. On utilise ensuite le module statistics pour calculer la moyenne et l'écart-type du temps d'exécution :
L'exécution de ce programme donne la moyenne et l'écart-type du temps d'exécution sur $100$ exécutions de l'appel fib(25) :
Temps d'exécution : - Moyenne : 0.04ms - Écart-type : 0.002ms
Le deuxième problème de cette méthode est qu'il faut modifier le code à mesurer, de manière plutôt intrusive, pour pouvoir effectuer les mesures des temps d'exécution, problème que l'on n'avait pas avec les outils du système d'exploitation.