|
このページは大阪弁化フィルタによって翻訳生成されたんですわ。 |
Famed was this Beowulf: far flew the boast of him, son of Scyld, in the Scandian lands. So becomes it a youth to quit him well with his father's friends, by fee and gift, that to aid him, aged, in after days, come warriors willing, should war draw nigh, liegemen loyal: by lauded deeds shall an earl have honor in every clan.
Il y a peut-黎re de nombreuses d馭initions de Beowulf, autant que de personnes qui construisent ou utilisent des Superordinateurs Beowulf. Certains disent qu'ils peuvent appeler leur syst鑪e Beowulf seulement s'il est construit de la autre r駸eau. C'est un syst鑪e construit en utilisant des composants mat駻iels existants, comme tout PC capable de faire tourner Linux, des adaptateurs Ethernet standards, et des switches. Il ne contient aucun composant mat駻iel propre et est ais駑ent reproductible. Beowulf utilise aussi des 駘駑ents comme le syst鑪e d'exploitation Linux, Parallel VirtualMachine (PVM) et Message Passing Interface (MPI). Le noeud serveur contr?e l'ensemble du cluster et sert de serveur de fichiers pour les noeuds clients. Il est aussi la console du cluster et la passerelle (gateway) vers le monde ext駻ieur. De grandes machines Beowulf peuvent avoir plus d'un noeud serveur, et 騅entuellement aussi d'autres Beowulf et un Cluster de Stations de travail (COW) est le fait que Beowulf se comporte plus comme une simple machine plut? que comme plusieurs stations de travail. Dans de nombreux cas, les noeuds clients n'ont pas de claviers ni de
Beowulf n'est pas un ensemble de mat駻iels sp馗ialis駸, une nouvelle
topologie r駸eau ou le dernier hack du kernel. Beowulf est une technologie de
clustering d'ordinateurs Linux pour former un superordinateur parall鑞e,
Standard de Linux sans ajouter d'autres logiciels. Si vous avez deux Linux en
r駸eau qui partagent au moins le m麥e syst鑪e de fichier racine via
NFS, et qui se font confiance pour ex馗uter des sessions distantes (rsh), alors
CLASSE I BEOWULF:
Cette classe concerne des machines faites d'駘駑ents globalement disponibles. Nous devrons utiliser les tests de certification "Computer Shopper" pour d馭inir les composants d'assemblage. ("Computer Shopper" est un mensuel sur les PC et
CLASSE II BEOWULF
Un Beowulf CLASSE II Beowulf est simplement une machine qui ne passe pas le test de certification "Computer Shopper". Ce n'est pas une mauvaise chose. D'autre part, il s'agit plut? d'une classification de la machine.
Les avantages d'un syst鑪e de CLASSE II sont:
Les d駸avantages des syst鑪es de CLASSE II sont:
Une CLASSE n'est pas n馗essairement meilleure qu'une autre. Cela d駱end surtout de vos besoins et de votre budget. Cette classification des syst鑪es sert
Je pense que la meilleure fa輟n de d馗rire l'architecture d'un superordinateur Beowulf est d'utiliser un exemple qui est tr鑚 proche du vrai Beowulf, mais NIS et NFS.
Maintenant que nous avons une vision correcte de l'architecture du syst鑪e,
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駱ertoire
de base, mais peut aussi 馗later la m麥e t稍he sur diff駻entes
machines simplement en ex馗utant un shell distant. Par exemple, si
nous voulons calculer la somme des racines carr馥s de tous les entiers
real 0m0.029s
user 0m0.001s
sys 0m0.024s
La commande time nous permet de v駻ifier le temps mis
en ex馗utant cette t稍he. Comme nous pouvons le voir, cet exemple
real 16m45.937s
user 16m43.527s
sys 0m0.108s
Cette fois, le temps d'ex馗ution de ce programme est consid駻ablement sup駻ieur. La question 騅idente qui se pose est: est-il possible de diminuer le temps d'ex馗ution de cette t稍he et comment ? La r駱onse 騅idente est de d馗ouper la t稍he en un ensemble de sous-t稍hes et d'ex馗uter ces sous-t稍hes en parall鑞e sur tous les ordinateurs. Nous pouvons s駱arer la grande t稍he d'addition en 20 parties en calculant un intervalle de racines carr馥s et en les additionnant sur un seul noeud. Quand tous les noeuds ont fini les calculs et retournent leurs r駸ultats, les 20 nombres peuvent 黎re additionn駸 ensemble et fournir la solution finale. Avant t稍he en parall鑞e. En fait la t稍he en parall鑞e s'est ex馗ut馥 17 fois plus vite, ce qui est tr鑚 raisonnable pour un facteur 20 d'augmentation du nombre de CPU. Le but de l'exemple pr馗馘ent est d'illustrer la m騁hode la plus simple de parall駘iser du code concurrent. En pratique, des exemples aussi simples sont rares et diff駻entes techniques (les API de PVM et PMI) sont utilis馥s pour obtenir le parall駘isme.
Avant d'acheter du mat駻iel, il serait de bon aloi de consid駻er le design de votre syst鑪e. Il y a deux approches mat駻ielles qui sont impliqu馥s dans le design d'un syst鑪e Beowulf: le type de noeuds ou d'ordinateurs que vous allez utiliser, et la m騁hode que vous allez utiliser pour vous connecter aux noeuds d'ordinateurs. Il n'y a qu'une seule approche logicielle qui puisse affecter votre choix mat駻iel: la librairie de communication ou API. Une discussion plus d騁aill馥 sur le mat駻iel et les logiciels de communication est fournie plus loin dans ce document.
Alors que le nombre de choix n'est pas grand, il y a des consid駻ations de conception qui doivent 黎re prises pour la construction d'un cluster Beowulf. La science (ou art) de la "programmation parall鑞e" 騁ant l'objet de nombreuses interpr騁ations, une introduction est fournie plus bas. Si vous ne voulez pas lire les connaissances de base, vous pouvez survoler cette section, mais nous vous conseillons de lire la section Convenance avant tout choix d馭ninitif de mat駻iel.
Cette section fournit des informations g駭駻ales sur les concepts de la programmation parall鑞e. Ceci n'est PAS exhaustif, ce n'est pas une description compl鑼e de la programmation parall鑞e ou de sa technologie. C'est une br钁e description des enjeux qui peuvent influer fortement sur le concepteur d'un Beowulf, ou sur son utilisateur.
Lorsque vous d馗iderez de construire votre Beowulf, de nombreux points d馗rits plus bas deviendront importants dans votre processus de choix. A cause de la nature de ses "composants", un Superordinateur Beowulf n馗essite de prendre de nombreux facteurs en compte, car maintenant ils d駱endent de nous. En g駭駻al,
La programmation parall鑞e peut prendre plusieurs formes. Du point de vue de l'utilisateur, il est important de tenir compte des avantages et inconv駭ients de chaque m騁hodologie. La section suivante tente de fournir quelques aper輹s traitement de texte sonne comme "trop inutile" -- et ce l'est. Et qu'en est-il pour un serveur web, une base de donn馥s, un programme de ray-tracing, ou un planificateur de projets ? Peut-黎re plus de CPU peuvent-ils am駘iorer les performances. Mais qu'en est-il de simulations plus complexes, de la dynamique des fluides, ou d'une application de Fouille de Donn馥s (Data Mining) ? Des CPU suppl駑entaires sont absolument n馗essaires dans ces situations. D'ailleurs, de multiples CPU sont utilis駸 pour r駸oudre de plus en plus de probl鑪es.
s'il n'y a personne dans la queue, vous serez servi plus vite.Exemple en Informatique : UNIX, NT avec un seul CPU
Exemple en Informatique : UNIX, NT avec plusieurs CPU
Exemple en Informatique : UNIX ou NT avec plusieurs CPU sur la m麥e carte-m鑽e avec des programmes multi-threads.
Exemple en Informatique : Une ou plusieurs copies d'UNIX ou NT avec plusieurs CPU sur la m麥e, ou diff駻entes cartes-m鑽es communiquant par messages.
Les sc駭arios pr馗馘ents, m麥e s'ils ne sont pas exacts, sont une bonne repr駸entation des contraintes qui agissent sur les syst鑪es parall鑞es. Contrairement aux machines avec un seul CPU (ou caisse), la communication est importante.
Les m騁hodes et architectures habituelles de la programmation parall鑞e sont repr駸ent馥s ci-dessous. M麥e si cette description n'est en aucun cas exhaustive, elle est suffisante pour comprendre les imp駻atifs de base dans la conception d'un Beowulf.
Il y a typiquement deux fa輟ns d'assembler un ordinateur parall鑞e:
Il est aussi possible de connecter des machines SMP en tant que noeuds de m駑oire locale. Typiquement, les cartes-m鑽es de CLASSE I ont soit 2 ou 4 CPU et
Il y a basiquement deux fa輟ns d'"exprimer" la concurrence dans un programme:
Pour ex馗uter une application en parall鑞e sur des CPU multiples, celle-ci doit 黎re explicitement d馗oup馥 en parties concurrentes. Une application standard mono-CPU ne s'ex馗utera pas plus rapidement m麥e si elle est ex馗ut馥 sur une machine multi-processeurs. Certains outils et compilateurs peuvent d馗ouper les programmesn mais la parall駘isation n'est pas une op駻ation "plug and play". Suivant l'application, la parall駘isation peut 黎re facile, extr麥ement difficile, voire impossible suivant les contraintes de l'algorithme.
Avant de parler des besoins applicatifs, il nous faut introduire le concept de Convenance (Suitability).
Beaucoup de questions au sujet du calcul parall鑞e ont la m麥e r駱onse:
"Cela d駱end enti鑽ement de l'application."
Avant de passer directement aux opportunit駸, il y a une distinction tr鑚 importante qui doit 黎re faite: la diff駻ence entre CONCURRENT et PARALLELE. Pour clarifier cette discussion, nous allons d馭inir ces deux termes ainsi:
calcul, sinon l'ex馗ution PARALLELE des parties CONCURRENTES est inefficace.La t稍he du programmeur est de d騁erminer quelles parties CONCURRENTES le programmeur DOIT ex馗uter en PARALLELE et pour quelles parties il NE DOIT PAS le faire. Sa r駱onse d騁erminera l'EFFICACITE de l'application. Le graphe suivant r駸ume la situation pour le programmeur:
| *
| *
| *
% des | *
appli- | *
cations | *
| *
| *
| *
| *
| *
| ****
| ****
| ********************
+-----------------------------------
temps de communication/temps de calcul
Beowulf, l'utilisateur devrait garder celui-ci en t黎e parce que la performance
d駱end du rapport entre le temps de communication et le temps de calcul pour un
ORDINATEUR PARALLELE SPECIFIQUE. Les applications peuvent 黎re portables entre
d駱end du rapport communication/calcul, changer juste un composant du rapport ne
signifie pas n馗essairement qu'une application s'ex馗utera plus rapidement. Un
changement de vitesse processeur, en gardant la m麥e vitesse de communication,
peut avoir des effets inattendus sur votre programme. Par exemple, doubler ou
tripler la vitesse du processeur, en gardant la m麥e vitesse de communication,
peut maintenant rendre des parties de votre programme qui sont efficaces en
PARALLELE, plus efficaces si elles 騁aient ex馗ut馥s SEQUENTIELLEMENT. Cela dit,
il se peut qu'il soit plus rapide maintenant d'ex馗uter les parties qui 騁aient
avant PARALLELES en tant que SEQUENTIELLES. D'autant plus qu'ex馗uter des
UPGRADER VERS UN CPU PLUS RAPIDE PEUT REELLEMENT RALENTIR VOTRE APPLICATION
Donc, en conclusion, pour savoir si oui ou non vous pouvez utiliser un environnement mat駻iel parall鑞e, vous devez avoir un bon aper輹 des capacit駸 d'une machine particuli鑽e pour votre application. Vous devez tenir compte de beaucoup de facteurs: vitesse de la CPU, compilateur, API de passage de messages, r駸eau... Notez que se contenter d'optimiser une application ne donne pas toutes les informations. Vous pouvez isoler une lourde partie de calcul de votre programme, mais ne pas conna?re son co? au niveau de la communication. Il se peut que pour un certain syst鑪e, le co? de communication ne rende pas efficace de parall駘iser ce code.
En g駭駻al, vous pouvez faire deux choses:
Examinons-les successivement:
Cette 騁ape est couvent consid駻馥 comme "parall駘iser votre programme". Les concurrence: calcul (travaux num駻iques) et E/S (Bases de Donn馥s). M麥e si dans de nombreux cas, la concurrence entre calculs et E/S est orthogonale, des applications ont besoin des deux. Des outils existants peuvent faire l'analyse de la concurrence sur des applications existantes. La plupart ou seulement de bons vieux r馭lexes bien 馘uqu駸. Si vous avez une application sp馗ifique en t黎e, essayez de d騁erminer la limite du CPU (li馥 au calcul) ou les limites des disques (li馥s aux E/S). Les sp馗ifit駸 de votre Beowulf peuvent avoir des contraintes de co?s qui doivent 黎re optimis馥s. Pour les probl鑪es li駸 aux E/S, il existe une loi peu connue (appel馥 la loi de Eadline-Dedkov) qui est assez utile:
Soient deux machines parall鑞es avec le m麥e index de performance CPU cumul馥, celle qui a les processeurs les plus lents (et probablement un r駸eau de communication interprocesseur plus lent) aura les meilleures performances pour des applications domin馥s par les E/S.
description des outils Logiciels.En l'absence d'outils, il vous faudra peut-黎re improviser votre chemin lors de cette 騁ape. Si une boucle li馥 aux calculs est mesur馥 en minutes et que les donn馥s peuvent 黎re transf駻馥s en secondes, alors c'est un bon candidat pour la parall駘isation. Mais souvenez-vous que si vous prenez une boucle de 16 minutes et la coupez en 32 morceaux, et que vos transferts de donn馥s ont besoin de quelques secondes par partie, alors cela devient plus r馘uit en termes de performances. Vous atteindrez un point de retours en diminution.
Il y a plusieurs fa輟ns de d馗rire les parties concurrentes de votre programme:
Les m騁hodes implicites sont celles dans lesquelles l'utilisateur abandonne quelques d馗isions de parall駘isation (ou toutes) au compilateur. Par exemple le FORTRAN 90, High Performance FORTRAN (HPF), Bulk Synchronous Parallel (BSP), et toute une s駻ie de m騁hodes qui sont en cours de d騅eloppement.
Les m騁hodes implicites n馗essitent de la part de l'utilisateur des informations concernant la nature concurrente de leur application, mais le compilateur beowulf-request@cesdis.gsfc.nasa.gov avec le mot subscribe dans le corps du message.
/* Jacek Radajewski jacek@usq.edu.au */
/* 21/08/1998 */
#include <stdio.h>
#include <math.h>
int main (void) {
double result = 0.0;
double number = 0.0;
char string[80];
while (scanf("%s", string) != EOF) {
number = atof(string);
result = result + number;
}
printf("%lf\n", result);
return 0;
}
/* Jacek Radajewski jacek@usq.edu.au */
/* 21/08/1998 */
#include <stdio.h>
#include <math.h>
int main (int argc, char** argv) {
long number1, number2, counter;
double result;
if (argc < 3) {
printf ("usage : %s number1 number2\n",argv[0]);
exit(1);
} else {
number1 = atol (argv[1]);
number2 = atol (argv[2]);
result = 0.0;
}
for (counter = number1; counter <= number2; counter++) {
result = result + sqrt((double)counter);
}
printf("%lf\n", result);
return 0;
}
#!/bin/bash # Jacek Radajewski jacek@usq.edu.au # 21/08/1998 export SIGMASQRT=/home/staff/jacek/beowulf/HOWTO/example1/sigmasqrt rsh scilab02 $SIGMASQRT 50000001 100000000 > $OUTPUT < /dev/null& rsh scilab03 $SIGMASQRT 100000001 150000000 > $OUTPUT < /dev/null& rsh scilab04 $SIGMASQRT 150000001 200000000 > $OUTPUT < /dev/null& rsh scilab05 $SIGMASQRT 200000001 250000000 > $OUTPUT < /dev/null& rsh scilab06 $SIGMASQRT 250000001 300000000 > $OUTPUT < /dev/null& rsh scilab07 $SIGMASQRT 300000001 350000000 > $OUTPUT < /dev/null& rsh scilab08 $SIGMASQRT 350000001 400000000 > $OUTPUT < /dev/null& rsh scilab09 $SIGMASQRT 400000001 450000000 > $OUTPUT < /dev/null& rsh scilab10 $SIGMASQRT 450000001 500000000 > $OUTPUT < /dev/null& rsh scilab11 $SIGMASQRT 500000001 550000000 > $OUTPUT < /dev/null& rsh scilab12 $SIGMASQRT 550000001 600000000 > $OUTPUT < /dev/null& rsh scilab13 $SIGMASQRT 600000001 650000000 > $OUTPUT < /dev/null& rsh scilab14 $SIGMASQRT 650000001 700000000 > $OUTPUT < /dev/null& rsh scilab15 $SIGMASQRT 700000001 750000000 > $OUTPUT < /dev/null& rsh scilab16 $SIGMASQRT 750000001 800000000 > $OUTPUT < /dev/null& rsh scilab17 $SIGMASQRT 800000001 850000000 > $OUTPUT < /dev/null& rsh scilab18 $SIGMASQRT 850000001 900000000 > $OUTPUT < /dev/null& rsh scilab19 $SIGMASQRT 900000001 950000000 > $OUTPUT < /dev/null& rsh scilab20 $SIGMASQRT 950000001 1000000000 > $OUTPUT < /dev/null&