3. Aperçu de l'Architecture

3.1 A quoi cela ressemble-t-il ?

Je pense que la meilleure façon de décrire l'architecture d'un superordinateur Beowulf est d'utiliser un exemple qui est très proche du vrai Beowulf, mais aussi familier à beaucoup d'administrateurs systèmes. L'exemple le plus proche d'une machine Beowulf est un Unix de laboratoire avec un serveur et un certain nombre de clients. Pour être plus spécifique, j'utiliserai le DEC Alpha au laboratoire d'informatique de la Faculté des Sciences de l'USQ comme exemple. Le serveur est appelé beldin et les machines clientes sont scilab01, scilab02, scilab03, jusqu'à scilab20. Tous les clients ont une copie locale du système d'exploitation Digital Unix 4.0 installé, mais ont l'espace disque utilisateur (/home) et /usr/local du serveur via NFS (Network File System). Chaque client a une entrée pour le serveur et tous les autres clients dans son fichier /etc/hosts.equiv: ainsi tous les clients peuvent exécuter une cession distante (rsh) vers tout autre. La machine serveur est un serveur NIS pour tout le laboratoire, ainsi les informations des comptes sont les mêmes sur toutes les machines. Une personne peut s'asseoir à la console de scilab02, se logue, et a le même environnement que s'il était logué sur le serveur, ou scilab15. La raison pour laquelle les clients ont la même présentation est que le système d'exploitation est installé et configuré de la même façon sur toutes les machines, les espaces /home et /usr/local sont physiquement sur le même serveur et les clients y accèdent via NFS. Pour plus d'informations sur NIS et NFS, reportez-vous à NIS et NFS.

3.2 Comment utiliser les autres noeuds ?

Maintenant que nous avons une vision correcte de l'architecture du système, regardons comment nous pouvons utiliser les cycles CPU des machines dans le laboratoire. Toute personne peut se loguer sur n'importe laquelle des machines, et lancer un programme dans son répertoire de base, mais peut aussi éclater la même tâche sur différentes machines simplement en exécutant un shell distant. Par exemple, si nous voulons calculer la somme des racines carrées de tous les entiers inclus strictement entre 1 et 10, nous écrivons un simple programme appelé sigmasqrt (voir code source) qui fait cela exactement. Pour calculer la somme des racines carrées des nombres de 1 à 10, nous exécutons :

[jacek@beldin sigmasqrt]$ time ./sigmasqrt 1 10
22.468278
real    0m0.029s
user    0m0.001s
sys     0m0.024s

[jacek@beldin sigmasqrt]$ time ./sigmasqrt 1 1000000000
21081851083600.559000
real    16m45.937s
user    16m43.527s
sys     0m0.108s

Cette fois, le temps d'exécution de ce programme est considérablement supérieur. La question évidente qui se pose est: est-il possible de diminuer le temps d'exécution de cette tâche et comment ? La réponse évidente est de découper la tâche en un ensemble de sous-tâches et d'exécuter ces sous-tâches en parallèle sur tous les ordinateurs. Nous pouvons séparer la grande tâche d'addition en 20 parties en calculant un intervalle de racines carrées et en les additionnant sur un seul noeud. Quand tous les noeuds ont fini les calculs et retournent leurs résultats, les 20 nombres peuvent être additionnés ensemble et fournir la solution finale. Avant de lancer ce processus, nous allons créer un "named pipe" qui sera utilisé par tous les processus pour écrire leurs résultats:

[jacek@beldin sigmasqrt]$ mkfifo output
[jacek@beldin sigmasqrt]$ ./prun.sh & time cat output | ./sum
[1] 5085
21081851083600.941000
[1]+  Done                    ./prun.sh
real    0m58.539s
user    0m0.061s
sys     0m0.206s

Cette fois, cela prend 58.5 secondes. C'est le temps qui a été nécessaire entre le démarrage du processus et le moment où les noeuds ont fini leurs calculs et écrit leurs résultats dans la pipe. Ce temps n'inclut pas l'addition finale des 20 nombres, mais il représente une petite fraction de seconde et peut être ignoré. Nous pouvons voir qu'il y a un avantage significatif à exécuter une tâche en parallèle. En fait la tâche en parallèle s'est exécutée 17 fois plus vite, ce qui est très raisonnable pour un facteur 20 d'augmentation du nombre de CPU. Le but de l'exemple précédent est d'illustrer la méthode la plus simple de paralléliser du code concurrent. En pratique, des exemples aussi simples sont rares et différentes techniques (les API de PVM et PMI) sont utilisées pour obtenir le parallélisme.

3.3 En quoi un Beowulf diffère-t-il d'un COW ?

Le laboraroire d'informatique décrit plus haut est un exemple parfait d'un cluster de stations (COW). Qu'est-ce qui rend donc Beowulf si spécial et en quoi diffère-t-il d'un COW ? En réalité il n'y a pas beaucoup de différence, mais un Beowulf a quelques caractéristiques uniques. La première est que dans la plupart des cas, les noeuds clients dans un cluster Beowulf n'ont pas de clavier, de souris, de carte graphique ni de moniteur. Tous les accès aux noeuds clients sont faits par une connection distante du noeud serveur, un noeud dédié à une console, ou une console série. Cela parce qu'il n'y a aucun besoin pour un noeud client d'accéder à des machines en dehors du cluster, ni pour des machines en dehors du cluster d'accéder à des noeuds clients directement; c'est une pratique habituelle que les noeuds clients utilisent des adresses IP privées comme les plages d'adresses 10.0.0.0/8 ou 192.168.0.0/16 (RFC 1918 http://www.alternic.net/rfcs/1900/rfc1918.txt.html). D'habitude la seule machine qui est aussi connectée au monde externe en utilisant une seconde carte réseau est le noeud serveur. La façon la plus habituelle d'accéder au système est soit d'utiliser la console du serveur directement, soit de faire un telnet ou un login distant (rlogin) sur le noeud serveur d'une station personnelle. Une fois sur celui-ci, les utilisateurs peuvent éditer et compiler leur code, et aussi distribuer les tâches sur tous les noeuds du cluster. Dans la plupart des cas, les COW sont utilisées pour des calculs parallèles la nuit et les week-ends, quand les stations ne sont pas utilisées pendant les journées de travail, utilisant ainsi les périodes de cycles libres des CPU. D'autre part, le Beowulf est une machine dédiée au calcul parallèle, et optimisée pour cette tâche. Il donne aussi un meilleur rapport prix/performance puisqu'il est constitué de composants grand public et qu'il tourne principalement à partir de logiciels libres. Beowulf donne aussi davantage l'image d'une seule machine, ce qui permet aux utilisateurs de voir le cluster Beowulf comme une seule station de calcul.