WEBVTT

00:00:00.800 --> 00:00:02.450 align:middle
Bonjour. Dans ce cours je
vais vous montrer comment on

00:00:02.650 --> 00:00:05.290 align:middle
peut faire du profilage
d'application en Pharo.

00:00:05.660 --> 00:00:07.660 align:middle
Ça veut dire comment on
va mesurer l'exécution de

00:00:07.860 --> 00:00:09.830 align:middle
certaines expressions et
pour savoir si on peut les

00:00:10.030 --> 00:00:12.580 align:middle
remplacer par d'autres pour
gagner du temps, lors de l'exécution

00:00:12.780 --> 00:00:13.540 align:middle
d'un programme.

00:00:14.830 --> 00:00:17.030 align:middle
En gros ce que disent les
gens, c'est que quand on n'a

00:00:17.230 --> 00:00:20.100 align:middle
jamais fait de profilage
d'une application, on a

00:00:20.300 --> 00:00:22.140 align:middle
potentiellement un
gain entre 40 et 50 %.

00:00:22.340 --> 00:00:25.200 align:middle
Moi, je n'en suis pas
convaincu ou je ne le sais pas, je

00:00:25.400 --> 00:00:26.310 align:middle
n'ai pas la preuve
de ce genre de choses.

00:00:26.510 --> 00:00:28.250 align:middle
Par contre, je vais vous
montrer quels sont les outils

00:00:28.450 --> 00:00:31.420 align:middle
qui existent en Pharo
pour faire ce profilage.

00:00:32.720 --> 00:00:34.780 align:middle
La première expression qui
existe en Pharo, c'est timeToRun.

00:00:36.170 --> 00:00:38.870 align:middle
C'est un message qu'on va
envoyer à un block qui va nous

00:00:39.070 --> 00:00:40.760 align:middle
dire le temps
d'exécution d'une expression.

00:00:41.610 --> 00:00:45.930 align:middle
Là par exemple sur
factoriel 1 000, je veux mesurer le

00:00:46.130 --> 00:00:47.650 align:middle
temps d'exécution de
factoriel 1 000, je le mets dans un

00:00:47.850 --> 00:00:49.770 align:middle
bloc et j'envoie le
message timeTo Run.

00:00:51.150 --> 00:00:55.000 align:middle
Une fois qu'on a timeToRun, c'est
très facile de comparer 2 exécutions.

00:00:55.370 --> 00:00:57.440 align:middle
Là, je vous propose un
petit exercice qui est de dire

00:00:57.790 --> 00:01:01.440 align:middle
est-ce que si je fais un
select suivi d'un collect, c'est

00:01:01.640 --> 00:01:04.740 align:middle
plus lent ou pas
qu'un select puis collect.

00:01:05.550 --> 00:01:07.800 align:middle
Sachant que là, ça
implique qu'il y aurait 2 passages

00:01:08.630 --> 00:01:10.680 align:middle
dans le premier cas et un
passage dans le deuxième cas.

00:01:11.510 --> 00:01:13.600 align:middle
Je pense que ce sera plus
lent mais on va le vérifier.

00:01:15.460 --> 00:01:20.040 align:middle
Je créé ma collection dans
les 2 cas de figure avec 10

00:01:20.240 --> 00:01:21.360 align:middle
éléments, c'est une
petite collection.

00:01:23.120 --> 00:01:27.930 align:middle
Je vais faire une

00:01:28.130 --> 00:01:31.000 align:middle
boucle pour pouvoir exécuter un
certain nombre de fois les 2 expressions.

00:01:31.200 --> 00:01:33.480 align:middle
Ce que vous voyez, c'est que
dans la première partie, là

00:01:33.680 --> 00:01:35.380 align:middle
j'ai ma collection et je
dis que je veux sélectionner

00:01:35.580 --> 00:01:38.940 align:middle
tous les éléments qui sont
plus grands que 5 et après,

00:01:39.140 --> 00:01:41.750 align:middle
ces éléments que j'aurais
sélectionnés, je veux les élever au carré.

00:01:42.160 --> 00:01:44.940 align:middle
Et dans la deuxième
expression, je vais dire que je veux

00:01:45.140 --> 00:01:49.840 align:middle
sélectionner ceux qui sont plus
grands que 5 et les élever au carré.

00:01:50.390 --> 00:01:52.230 align:middle
On voit que le système
me dit que là c'est 500

00:01:52.430 --> 00:01:55.670 align:middle
millisecondes et là c'est
368 millisecondes. Finalement,

00:01:56.020 --> 00:01:57.520 align:middle
il vaut mieux utiliser
la deuxième expression.

00:01:57.720 --> 00:01:59.010 align:middle
Vous voyez un petit peu
comment ça fonctionne.

00:01:59.210 --> 00:02:00.000 align:middle
Après, c'est à vous de le faire.

00:02:00.210 --> 00:02:02.370 align:middle
Ce qu'il faut voir, c'est
qu'effectivement on doit

00:02:02.570 --> 00:02:07.060 align:middle
parfois mettre de très
grandes boucles à l'intérieur pour

00:02:07.470 --> 00:02:09.130 align:middle
amplifier la mesure.

00:02:09.460 --> 00:02:11.020 align:middle
Il faut le faire dans les
2 cas pareil, évidemment.

00:02:12.340 --> 00:02:16.710 align:middle
Sinon, il y a un autre
message qui s'appelle bench qui

00:02:17.530 --> 00:02:19.640 align:middle
va nous dire combien de fois le code,

00:02:22.890 --> 00:02:27.810 align:middle
qui est étudié, a été
exécuté durant 5 secondes.

00:02:28.010 --> 00:02:30.250 align:middle
Là je reprends mon exemple
factoriel 1 000, bench, là je

00:02:30.450 --> 00:02:33.280 align:middle
vois que je peux
l'exécuter 110000 fois par seconde.

00:02:35.600 --> 00:02:38.920 align:middle
Dans ce cas de figure, ce qu'on veut
c'est que le chiffre soit le plus haut.

00:02:39.550 --> 00:02:42.730 align:middle
Il y a une variante de
bench qui s'appelle bench for où

00:02:42.930 --> 00:02:44.500 align:middle
vous pouvez spécifier la taille.

00:02:44.700 --> 00:02:48.000 align:middle
Là ce qui est sympa, c'est
de voir que 2 secondes, c'est

00:02:48.200 --> 00:02:51.530 align:middle
vraiment le message secondes
qui est envoyé au message 2,

00:02:52.280 --> 00:02:56.000 align:middle
ça va nous donner sûrement
une duration, une instance de

00:02:56.200 --> 00:03:00.390 align:middle
la classe duration qui va
contrôler combien de temps le

00:03:00.590 --> 00:03:01.350 align:middle
système va tourner.

00:03:01.550 --> 00:03:03.760 align:middle
Vous voyez, ça c'est encore
une illustration que tout est

00:03:03.960 --> 00:03:06.870 align:middle
objet dans Pharo, donc
spécifier les secondes, je fais 2

00:03:07.070 --> 00:03:10.920 align:middle
secondes, j'envoie le
message secondes à l'objet 2.

00:03:12.100 --> 00:03:15.890 align:middle
Il y a aussi ce qu'on
appelle un profiler qui est basé

00:03:16.090 --> 00:03:19.340 align:middle
sur des techniques de
sample. Vous allez exécuter votre

00:03:20.220 --> 00:03:23.900 align:middle
 programme et lui, il va
aller à intervalles réguliers

00:03:24.100 --> 00:03:27.040 align:middle
inspecter la pile
d'exécution et voir ce qui est sur

00:03:27.240 --> 00:03:29.000 align:middle
cette pile d'exécution et
collecter l'information.

00:03:29.920 --> 00:03:31.260 align:middle
Comment est-ce qu'on l'invoque ?

00:03:31.540 --> 00:03:35.680 align:middle
On fait TimeProfiler, spyOn
et on va lui passer un block.

00:03:36.470 --> 00:03:38.360 align:middle
Là je dis que je veux
répéter 20 fois que je vais

00:03:38.560 --> 00:03:43.060 align:middle
afficher sur le Transcript
factoriel 100 que je convertis

00:03:43.260 --> 00:03:45.200 align:middle
en chaîne, c'est ça qui
coûte le plus cher en général.

00:03:46.220 --> 00:03:49.800 align:middle
Et après, le profiler va
nous donner ce genre de

00:03:50.000 --> 00:03:52.750 align:middle
résultats avec un arbre qui
va nous montrer les branches

00:03:52.950 --> 00:03:54.100 align:middle
parmi lesquelles on a
passé le plus de temps.

00:03:54.300 --> 00:03:57.360 align:middle
Là par exemple, il nous
montre qu'on a passé 63 % du

00:03:57.560 --> 00:03:59.410 align:middle
temps dans la
méthode printOn by base.

00:04:02.000 --> 00:04:03.790 align:middle
C'est juste pour vous
montrer que ça existe, il y a un

00:04:04.000 --> 00:04:06.770 align:middle
profiler comme ça, vous pouvez
jouer avec si vous êtes intéressé.

00:04:08.620 --> 00:04:11.270 align:middle
En résumé, dans une
première approche, vous pouvez

00:04:11.470 --> 00:04:15.480 align:middle
utiliser timeToRun, bench
et le profiler, il y a un

00:04:15.680 --> 00:04:18.390 align:middle
chapitre dans le livre
"Deep into Pharo" qui montre ce

00:04:18.590 --> 00:04:20.890 align:middle
genre de techniques d'optimisation.

00:04:21.270 --> 00:04:24.330 align:middle
Maintenant, je voulais
juste faire une petite remarque.

00:04:24.530 --> 00:04:26.860 align:middle
C'est que vous voyez que
dans ces 3 exemples à chaque

00:04:27.060 --> 00:04:29.830 align:middle
fois on utilise des blocks,
ça veut dire que là ici c'est

00:04:30.030 --> 00:04:31.780 align:middle
un block, là aussi c'est un block.

00:04:32.000 --> 00:04:34.660 align:middle
Pourquoi? Parce que ce que
vous avez vu dans le cours

00:04:34.860 --> 00:04:39.520 align:middle
sur les blocks, c'est
que la définition du block

00:04:39.780 --> 00:04:42.350 align:middle
n'exécute pas et donne
la possibilité à bench de

00:04:43.510 --> 00:04:46.380 align:middle
contrôler le nombre
d'exécutions, ou de décider quand on

00:04:46.580 --> 00:04:47.630 align:middle
commence l'exécution du programme.

00:04:48.370 --> 00:04:50.710 align:middle
L'autre remarque que j'ai
à vous faire, c'est soyez

00:04:50.910 --> 00:04:53.370 align:middle
curieux, allez voir comment
timeToRun est implémenté et

00:04:53.570 --> 00:04:55.910 align:middle
comment bench est
implémenté. Pour ça, vous n'avez qu'à

00:04:56.110 --> 00:04:59.290 align:middle
cliquer sur l'expression, et
faire browse ou implementer

00:04:59.490 --> 00:05:00.510 align:middle
dessus et vous allez voir le code.