L'Epistémotron
Membres potentiels du projet
Code-Source du programme écrit par Olivier Le Roy (simulation ci-dessous)
s
olivier_le_roy
yahoo.com
téléphone : 01 49 48 01 28
Son message du 24 mars 2004
Bonjour,
le fichier ci-joint est le source d'un programme de calcul astro mono-machine, il contient les explications de son fonctionnement.
Il y a également une liste de diffusion vers laquelle les développeurs qui se mettent en rapport peuvent poursuivre sur l'épistémotron.
http://groups.yahoo.com/group/SimToile/
Cordialement
Olivier Le Roy
18 mars 2004
sebastien75
tiscali.fr
Configuration :
CPU : ATHLON XP 3000+ BARTON
RAM : 512 MoConnexion internet : ADSL 2Mbits/s
PC tournant 24H/24
24 mars 2004/ Message de Xavier :
Bonjour,
voici quelques idées pour faire suite a l'idée de recherche d'un
logiciel ou d'une architecture utilisant , un peu a la manière du projet
seti-at-home, les possiblilités de calcul d'un grand nombre de machines
connectées a internet, pour effectuer des calculs d'astrophysique, je
me suis demandé si cette idée était valable, et j'ai commencé
à réfléchir sur la question: problème de performances
liées au problème de la "bande passante" entre les serveurs
interconnectés, entre autre. Après une recherche sur internet,
j'ai découvert que ce type d'architecture répartie logicielle
existait déja, et semblerait répondre aux demandes exprimées
par le projet.
Je préconiserais donc d'utiliser le "logiciel" NetsSolve. Une
présentation de cet outil et de ses nombreuses possibilités est
disponible a cette adresse et en Français:
http://www.lifl.fr/~boulet/formation/syst-dist/exposes2003-2004/netsolve/
sur le site du LIFL (Université des Sciences et Techniques de Lilles).
Il y a également des présentations très intéressantes
sur les supercalculateurs, les puissances, les couts, et... Netsolve http://www.lifl.fr/~boulet/formation/syst-dist/index.php
(très accessible).
On voit que c'est une alternative... crédible, mais pas dans tous les cas de figure. C'est normal, et on ne peut pas tout avoir, un Cray au prix d'un PC, le beurre, la crémière, sa fille, etc.. -:)
Le logiciel NetSolve:
=====================
http://icl.cs.utk.edu/netsolvedev/documents/ug/html/UG.html
(dont voici la doc, sur le site officiel de NetSolve)
L'avantage de l'existence d'une telle solution est...
qu'il n'y a pas a devoir l'écrire entièrement, a la développer,
en partant de rien (ce qui serait une démarche... courageuse, mais peut
etre un peu longue -:). Dans un premier temps en effet, je pensais partir de
zéro, mais il me semble que ce "produit", qui est gratuit,
répond exactement aux caractéristiques dont je pensais que devait
disposer un tel
produit tel que par exemple:
- logiciel en libre accès, source disponible
- architecture répartie
- disponibilité sur de multiples plateformes telles que linux et windows
(client)
Par ailleurs Netsolve sait faire des hypothèses pour choisir sur le réseau
"le meilleur serveur" pour éxécuter en remote tel ou
tel calcul. La sécurité peut etre implémentée via
kerberos, et netsolve utilise xdr de sun pour l'échange de données
entre systèmes hétérogènes.
L'utilisation:
Elle ne fait pas l'impasse sur la nécessité
de... programmer le calcul à soumettre, mais: on peut dire que netsolve
se charge de tout ce qui est execution distante, choix de la meilleure machine
disponible, cartographie des serveurs disponibles sur le réseau, etc...
Il existe par ailleurs des librairies d'interfaçage avec Fortran, C,
Matlab,
Mathematica et Octave (que je ne connais pas, mais que je salue au passage)
Donc, pour ce projet de calcul réparti, il suffit de créer des clients NetSolve, sous forme peut-être d'un économiseur d'écran, qui implémente les routines de calcul souhaitées, puis de proposer aux internautes de le télécharger. Un serveur linux se charge ensuite d'éxécuter le code principal de calcul. La différence (majeure) avec SETI est que le programme principal (linux) éxecute des procédures, ou fonction, de manière distante. Il peut ensuite attendre la réponse du "client calculateur distant" a son "appel de procédure", éxécuter la fonction. Epatant.
Un petit exemple:
resultat = sum(2,2);
la variable résultat sera "remplie" avec la valeur "4"
vu que la fonction "sum() " réalise.. une bête addition.
Transcendant ? pas vraiment. Mais dans ce simple exemple, le calcul est éxécuté
en local, sur ma machine, alors que avec un environnement réseau netsolve,
j'écrirais plutot (c'est un exemple):
résultat = netsolve ( sum (2,2) );
La fonction "netsolve()" dans cet exemple, fera... un maximum de boulot pour nous: elle se charge de trouver une machine de libre sur le réseau, évalue si cette machine est la mieux douée pour faire cette computation rapidement, éxecute le calcul sur cette machine et retourne le résultat au serveur appelant.
Conclusion: NetSolve semble un outil adéquat pour
faire du calcul (moyennement) parallèle sur (un grand nombre de) machines,
interconnectées par le protocole
TCP/IP (internet). Si l'on souhaite allez plus avant dans ce projet de calcul,
un peu de coordination entre les différents intervenants (sous la forme
d'un site web qui présente le projet par exemple) devrait permettre de
donner des résultats intéressants.
Reçu le 24 mars d'Olivier le Roy les fichiers correspondant à son programme de simulation.
Je les ai convertis en fichiers-textes. S'il y a un problème, contactez-je.
olivier_le_roy
yahoo.com
Premier fichier. Nom :
smp.h
Contenu :
/* smp.h */
/* Nombre de particules */
#define N 10648 /* 10648 */
/* Classes de vitesse */
#define classes_vitesse 10
/* Masse particule */
const double m=1.99e30;
/* Constante de gravitation */
const double G=6.6742e-11;
/* Diamètre particule */
const double diam=1392530000;
/* Vitesse max */
const double vmax=100000;
/* Pas de calcul */
const double delta=1000*365.25*24*3600;double position[N][3],vitesse[N][3],acceleration[N][3];
double lmax, r, theta, phi;
int compteur;
void init(void);
void display(void);
void reshape(int w, int h);
void keyboard(unsigned char key, int x, int y);
void calcul(void);
Deuxième fichier. Nom :
README.txt
Contenu :
Compilation:
============
Compile command: gcc -o smp smp.c -O3 -Wall -L/usr/X11R6/lib -lGL -lGLU -lglut -lm
Configuration:
==============
Nombre de points masse N au début du fichier smp.h à la ligne
#define N nombre_pts_masses
Nombre de classes de vitesse dans le fichier smp.h à la ligne #define
classes_vitesse
Commandes clavier:
==================
r s'éloigner de la scène.
R se rapprocher de la scène.
t se déplacer en coordonnées sphériques dans le sens theta
croissant.
T se déplacer en coordonnées sphériques dans le sens theta
décroissant.
f se déplacer en coordonnées sphériques dans le sens phi
croissant.
F se déplacer en coordonnées sphériques dans le sens phi
décroissant.
+------------------+
| Caractéristiques |
+------------------+
Calcul des conditions initiales: la vitesse initiale des particules a une direction
aléatoire et le module appartient à une classe de vitesse selon
une loi gaussienne.
Affichage: affichage dans un repère tridimentionnel en perspective.
Distribution initiale uniforme des particules.
Les particules rebondissent sur les parois.
Troisième fichier. Nom
smp.c
Contenu :
/***************************************************************************
smp.c - description
-------------------
begin : lun jan 12 19:22:18 CET 2004
copyright : (C) 2004 by Olivier Le Roy
email : oleroy@mail.transiciel.com
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include <GL/glut.h>
#include <stdio.h>
#include <stdlib.h> /* getenv(), etc. */
#include <stddef.h>
#include <math.h>
#include "smp.h"int main(int argc, char *argv[])
{
int i,j,m,n,p;
double v[classes_vitesse];
double a[N][3];
/* conditions initiales */
srand((unsigned int)time((time_t *)NULL));
lmax=2.0*pow(7.6998867e61*(double)N/200e9,1.0/3.0);
compteur=0;
for (j=0; j<3; j++) { /* acceleration initiale = 0 */
for (i=0; i<N; i++) acceleration[i][j]=0;
}
for(i=0; i<N; i++) {
theta=2.0*M_PI*rand()/RAND_MAX; /* vitesse initiale direction aleatoire */
phi=2.0*M_PI*rand()/RAND_MAX;
vitesse[i][0]=sin(phi)*cos(theta); /* r, theta, phi: coordonnees spheriques
*/
vitesse[i][1]=sin(phi)*sin(theta);
vitesse[i][2]=cos(phi);
}
for(i=0; i<classes_vitesse; i++) v[i]=vmax*exp(-50*pow((double)i/classes_vitesse,2.0));
/* 50: Largeur de la gaussienne à mi-hauteur */
for(i=0; i<N; i++) for(j=0; j<3; j++) vitesse[i][j]*=v[i%classes_vitesse];
/* Classes de vitesse */
for(i=0; i<N; i++) for(j=0; j<3; j++) a[i][j]=0;
for(i=0; i<N; i++) { /* 1er melange */
while(1) {
j=(int)((double)N*rand()/(RAND_MAX+1.0));
if(a[j][0]==0) break;
}
a[j][0]=vitesse[i][0];
a[j][1]=vitesse[i][1];
a[j][2]=vitesse[i][2];
}
for(i=0; i<N; i++) for(j=0; j<3; j++) vitesse[i][j]=0;
for(i=0; i<N; i++) { /* 2eme melange */
while(1) {
j=(int)((double)N*rand()/(RAND_MAX+1.0));
if(vitesse[j][0]==0) break;
}
vitesse[j][0]=a[i][0];
vitesse[j][1]=a[i][1];
vitesse[j][2]=a[i][2];
}
j=(int)pow((double)(N+1),1.0/3.0)-1; /* position distribution uniforme */
r=lmax/(double)j;
m=0;
n=0;
p=0;
for(i=0; i<N; i++) {
position[i][0]=(double)m*r;
position[i][1]=(double)n*r;
position[i][2]=(double)p*r;
m++;
if(m>j) {
m=0;
n++;
}
if(n>j) {
n=0;
p++;
}
}
r=3.2;
theta=331;
phi=70;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(900, 900);
glutInitWindowPosition(100,100);
glutCreateWindow("Simulation de mouvement de particules");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutIdleFunc(calcul);
glutMainLoop();
return EXIT_SUCCESS;
}
void init(void) {
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_FLAT);
glEnable(GL_POINT_SMOOTH); /* initialise le lissage pour le mode RVBA,
* y compris blending alpha, hint et
* largeur de point. */
glEnable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glHint(GL_POINT_SMOOTH_HINT | GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
glLineWidth(1.5);
glPointSize(4.0);
}
void display(void) {
int i;
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 1.0, 1.0);
glLoadIdentity(); /* vide la matrice */
/* transformation de visualisation */
gluLookAt(r*sin(phi*M_PI/180.0)*cos(theta*M_PI/180.0), r*sin(phi*M_PI/180.0)*sin(theta*M_PI/180.0),
r*cos(phi*M_PI/180.0), 1.0, 1.0, 1.0, 0.0, 0.0, 1.0);
glScalef(2.0, 2.0, 2.0); /* transformation de modélisation */
glBegin(GL_POINTS);
for(i=0; i<N; i++) glVertex4d(position[i][0], position[i][1], position[i][2],
lmax);
glEnd();
glColor3f(0.0, 1.0, 1.0); /* cyan */
glBegin(GL_LINES);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(1.0, 0.0, 0.0);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(0.0, 1.0, 0.0);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(0.0, 0.0, 1.0);
glEnd();
glFlush();
}
void reshape(int w, int h) {
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-1.0, 1.0, -1.0, 1.0, 1.5, 10.0);
glMatrixMode(GL_MODELVIEW);
}
void keyboard(unsigned char key, int x, int y) {
switch(key) {
case 'r':
r+=0.1;
printf("r= %g\n",r);
glutPostRedisplay();
break;
case 'R':
r-=0.1;
printf("r= %g\n",r);
glutPostRedisplay();
break;
case 't':
theta=(theta+1);
printf("theta= %g\n",theta);
glutPostRedisplay();
break;
case 'T':
theta=(theta-1);
printf("theta= %g\n",theta);
glutPostRedisplay();
break;
case 'f':
phi=(phi+1);
printf("phi= %g\n",phi);
glutPostRedisplay();
break;
case 'F':
phi=(phi-1);
printf("phi= %g\n",phi);
glutPostRedisplay();
break;
default:
break;
}
}
void calcul(void) {
int i,j;
double x,y,z,d;
compteur++;
printf("Trame N° %d\n",compteur);
for(i=0; i<N; i++) { /* calcul de la résultante de la force de
* gravitation en chacun des points. */
for(j=0; j<i; j++) { /* particules de 0 à i-1 */
x=position[j][0]-position[i][0];
y=position[j][1]-position[i][1];
z=position[j][2]-position[i][2];
d=sqrt(pow(x,2.0)+pow(y,2.0)+pow(z,2.0));
if (d<diam) d=diam;
d=pow(d,3.0)/(G*m);
acceleration[i][0]+= x/d;
acceleration[i][1]+= y/d;
acceleration[i][2]+= z/d;
}
for(j=i+1; j<N; j++) { /* particules de i+1 à N */
x=position[j][0]-position[i][0];
y=position[j][1]-position[i][1];
z=position[j][2]-position[i][2];
d=sqrt(pow(x,2.0)+pow(y,2.0)+pow(z,2.0));
if (d<diam) d=diam;
d=pow(d,3.0)/(G*m);
acceleration[i][0]+= x/d;
acceleration[i][1]+= y/d;
acceleration[i][2]+= z/d;
}
vitesse[i][0]+=acceleration[i][0]*delta;
vitesse[i][1]+=acceleration[i][1]*delta;
vitesse[i][2]+=acceleration[i][2]*delta;
position[i][0]+=vitesse[i][0]*delta;
position[i][1]+=vitesse[i][1]*delta;
position[i][2]+=vitesse[i][2]*delta;
if (position[i][0]<0) {
vitesse[i][0]=-vitesse[i][0]; /* Traiter rebond paroi x=0 */
position[i][0]=0;
}
if (position[i][0]>lmax) {
vitesse[i][0]=-vitesse[i][0]; /* Traiter rebond paroi x=lmax */
position[i][0]=lmax;
}
if (position[i][1]<0) {
vitesse[i][1]=-vitesse[i][1]; /* Traiter rebond paroi y=0 */
position[i][1]=0;
}
if (position[i][1]>lmax) {
vitesse[i][1]=-vitesse[i][1]; /* Traiter rebond paroi y=lmax */
position[i][1]=lmax;
}
if (position[i][2]<0) {
vitesse[i][2]=-vitesse[i][2]; /* Traiter rebond paroi z=0 */
position[i][2]=0;
}
if (position[i][2]>lmax) {
vitesse[i][2]=-vitesse[i][2]; /* Traiter rebond paroi z=lmax */
position[i][2]=lmax;
}
}
glutPostRedisplay();
}
24 mars 2004
Un autre participant potentiel :
pat.dev3
free.fr
Un autre, Frédéric Baudemont, informaticien, prêt à collaborer :
frederic.baudemontclub-internet.fr
Auteur d'un soft compilé en Borland C++ Builder et disposant d'une interface pour régler les paramètres. Essais avec 10.000 points et une journée de calcul, en 2d :
Dans le cas en question, c’est 3000 points environ. Avec 3000 Points,
un cycle de calcul prend environ 1 seconde. 20000 points c’est 1 minute
environ. Mes essais avec n>10000 ne m'avaient pas permis d'aller très
loin d'autant que je me suis rendu compte qu'il fallait un paquet de cycles
successifs et donc un pas de temps assez fin.
Essais avec 10.000 points et une journée de calcul, en 2d :
Autre participant :
adam
coatl.cotse.net
Non-développeurs mettant leur machine à diosposition
Retour
Nombre de consultations de cette page depuis le 25 mars 2004 :