Où écrire les intermédiaires ?

Partager les machines

Le piège du nettoyage

# FAUX : pkill tue aussi le shell distant, le rm ne s'execute jamais
$ ssh MACHINE "pkill -f travailleur.py ; rm -rf /tmp/bgd701-\$USER"

# JUSTE
$ ssh MACHINE "pkill -u \$USER -f '[t]ravailleur.py' ; rm -rf /tmp/bgd701-\$USER"

• [t]ravailleur.py reconnaît le travailleur, pas la commande elle-même
• Les apostrophes sont obligatoires : sinon zsh répond no matches found et n’exécute rien

Trois commandes

$ python3 deployer.py deployer 4
  ok      tp-1a201-10.enst.fr
  ok      tp-1a201-27.enst.fr
  ok      tp-1a201-31.enst.fr
  ok      tp-1a201-13.enst.fr
4 travailleur(s) dans travailleurs.txt (port 51114)

$ python3 maitre.py
TOTAL : 1.56 s
18810 mots distincts, 4/4 travailleurs utilises

$ python3 deployer.py nettoyer

Toujours vérifier

$ python3 verifier.py
distribue  :  1.37 s (4 travailleurs)
sequentiel :  2.07 s (1 processus)
OK : 18810 mots distincts, resultats identiques

L’accélération

$$S(p) = \frac{T(1)}{T(p)} \qquad\qquad E(p) = \frac{S(p)}{p}$$

• $S$ : combien de fois plus vite qu’avec une machine
• $E$ : la part de chaque machine réellement utile
• Trois mesures par point, on garde la médiane

Nos mesures

32 fichiers de 1 Mo, $R = 8$, travailleurs déjà lancés.

Pourquoi pas 16 fois plus vite ?

• Les vagues : à 16 machines, chacune fait encore 2 maps à la suite
• $R = 8$ : au-delà de 8 machines, le reduce n’accélère plus
• Les coûts fixes : connexions, barrière, collecte

Processeur ou disque ?

Un serveur de calcul passe 70 % de son temps dans les processeurs et 30 % sur les disques.

1. Lequel donne la meilleure performance ?
2. Lequel donne le meilleur rapport performance / coût ?

Le calcul, en minutes

Un calcul de 60 min : 42 min de processeur, 18 min de disque.

La loi d’Amdahl

$a$ = part du temps améliorée, $k$ = facteur d’accélération de cette part.

$$S = \frac{T_{\text{avant}}}{T_{\text{après}}} = \frac{1}{(1-a) + \dfrac{a}{k}}$$

Même infiniment rapide, le disque donnerait au plus $1/0\mathord{,}7$ : +43 %.

Le prix est-il le bon critère ?

• Un objectif : le calcul doit passer sous 45 min → aucune option ne suffit seule ; les deux ensemble : 35,2 min, pour 17 000 €
• Un budget : avec 8 000 €, seuls les disques sont possibles
• Le profil change avec le travail : un programme qui lit davantage inverse la conclusion

Le parallélisme : un cas particulier

$f$ = part séquentielle. Avec $p$ machines, la part $1 - f$ va $p$ fois plus vite :

$$S(p) = \frac{1}{f + \dfrac{1-f}{p}} \qquad\qquad S(\infty) = \frac{1}{f}$$

Sur notre système

• Avec 16 machines, accélération de 9,10 : $f \approx 5\,\%$, plafond ≈ 20
• Profil des maps (exercice 7.3) : calcul 79 %, lecture 15 %, écriture 6 %
• Une écriture infiniment rapide donnerait au mieux +6 %

Deux façons de mourir

4 machines, 32 fichiers. Sans panne : 6,1 s.

Refaire la tâche ailleurs

• Les tâches sont idempotentes : les refaire donne le même résultat
• Tout ce qui était sur le disque local d’un mort est perdu, même terminé
• Mesuré : machine tuée juste après la barrière → ses 8 maps terminés sont refaits
• Résultat final : identique au calcul sans panne

Les exercices

Ce qu’il faut retenir

• Intermédiaires sur /tmp : le disque local passe à l’échelle
• Machines partagées : port à votre nom, une connexion SSH à la fois, nettoyer et vérifier
• Même jeu de données à chaque mesure
• Amdahl : on accélère ce qui pèse le plus ; plafond $1/f$
• Tâches idempotentes : on les refait ailleurs
• Toujours comparer au calcul de référence