]> AND Private Git Repository - equilibrage.git/blob - simulation/generePlat.cpp
Logo AND Algorithmique Numérique Distribuée

Private GIT Repository
Ajout du contre-exemple à B&T.
[equilibrage.git] / simulation / generePlat.cpp
1 #include <iostream>
2 #include <fstream>
3 #include <sstream>
4 #include <string>
5 #include <vector>
6 #include <cstdlib>
7 #include <ctime>
8 #include <unistd.h>
9
10 using namespace std;
11
12 void aide(char *prog);
13 void genereLiensLigne(ofstream &fic, int nbNoeuds, int minB, int maxB, double minL, double maxL, bool liensDyns, double minP, double maxP, double intervalle);
14 void genereLiensAnneau(ofstream &fic, int nbNoeuds, int minB, int maxB, double minL, double maxL, bool liensDyns, double minP, double maxP, double intervalle);
15 void genereLiensComplet(ofstream &fic, int nbNoeuds, int minB, int maxB, double minL, double maxL, bool liensDyns, double minP, double maxP, double intervalle);
16 void genereRoutesLigne(ofstream &fic, int nbNoeuds, bool lienUnique);
17 void genereRoutesAnneau(ofstream &fic, int nbNoeuds, bool lienUnique);
18 void genereRoutesComplet(ofstream &fic, int nbNoeuds, bool lienUnique);
19 void genereDeploiementLigne(string &nom, int nbNoeuds);
20 void genereDeploiementAnneau(string &nom, int nbNoeuds);
21 void genereDeploiementComplet(string &nom, int nbNoeuds);
22
23 int main(int argc, char **argv)
24 {
25   int opt;
26   int nbNoeuds=10;                    // Taille du cluster
27   char topo='L';                      // Ligne, Anneau ou Complet
28   int minV=98095000, maxV=98095000;   // Vitesses min et max des procs
29   int minB=100000000, maxB=100000000; // Bandes passantes min et max
30   double minL=0.0001, maxL=0.0001;    // Latences min et max
31   bool liensDyns=false;               // Indique si les liens sont intermittants ou pas 
32   double minP=0.001,maxP=1.0;         // Intervalles de période pour les intermittences des liens
33   double intervalle=10.0;             // Taille de l'intervalle de temps pour les traces dynamiques des liens
34   long graine=1;                      // Initialisation générateur aléatoire
35   ofstream ficP;                      // Fichiers Plateforme et Déploiement
36   string nomFicP,nomFicD;             // Noms des fichiers
37   bool lienUnique=false;              // Indique si tous les liens sont identiques
38
39   while ((opt = getopt(argc, argv, "a:b:B:dD:f:F:g:i:l:L:n:P:t:v:V:")) != -1) {
40     switch (opt) {
41     case 'a':
42       graine=time(NULL);
43       break;
44     case 'b':
45       minB=atoi(optarg);
46       break;
47     case 'B':
48       maxB=atoi(optarg);
49       break;
50     case 'd':
51       liensDyns=true;
52       break;
53     case 'D':
54       nomFicD=string(optarg);
55       break;
56     case 'f':
57       minP=atof(optarg);
58       break;
59     case 'F':
60       maxP=atof(optarg);
61       break;
62     case 'g':
63       graine=atoi(optarg);
64       break;
65     case 'i':
66       intervalle=atof(optarg);
67       break;
68     case 'l':
69       minL=atof(optarg);
70       break;
71     case 'L':
72       maxL=atof(optarg);
73       break;
74     case 'n':
75       nbNoeuds=atoi(optarg);
76       break;
77     case 'P':
78       nomFicP=string(optarg);
79       break;
80     case 't':
81       topo=*optarg;
82       break;
83     case 'v':
84       minV=atoi(optarg);
85       break;
86     case 'V':
87       maxV=atoi(optarg);
88       break;
89     default:
90       aide(argv[0]);
91       return 1;
92     }
93   }
94
95   // Vérification de la spécification du nom de fichier
96   if(nomFicP.size()==0 || nomFicD.size()==0){
97     aide(argv[0]);
98     return 1;
99   }else{
100     cout << "Paramètres de génération de la plateforme :" << endl;
101     cout << "-----------------------------------------" << endl;
102     cout << "\tGraine      : " << graine << endl;
103     cout << endl;
104     cout << "\tNb noeuds   : " << nbNoeuds << endl;
105     cout << "\tTopologie   : " << ((topo=='L')?"Ligne":((topo=='A')?"Anneau":"Complet")) << endl;
106     cout << "\tVitesse min : " << minV << endl;
107     cout << "\tVitesse max : " << maxV << endl;
108     cout << "\tDébit min   : " << minB << endl;
109     cout << "\tDébit max   : " << maxB << endl;
110     cout << "\tLatence min : " << minL << endl;
111     cout << "\tLatence max : " << maxL << endl;
112     cout << "\tLiens dyns  : " << ((liensDyns)?"oui":"non") << endl;
113     if(liensDyns){
114       cout << "\t\tPériode min : " << minP << endl;
115       cout << "\t\tPériode max : " << maxP << endl;
116       cout << "\t\tIntervalle  : " << intervalle << endl;
117     }
118     cout << endl;
119     cout << "\tPlateforme  : " << nomFicP << endl;
120     cout << "\tDéploiement : " << nomFicD << endl;
121     cout << "-----------------------------------------" << endl;
122   }
123
124   // Init générateur aléat
125   srand(graine);
126   
127   // Génération du fichier de plateforme
128   ficP.open(nomFicP.c_str());
129   if(ficP.good()){
130     // En-tête
131     ficP << "<?xml version='1.0'?>" << endl;
132     ficP << "<!DOCTYPE platform SYSTEM \"simgrid.dtd\">" << endl;
133     ficP << "<platform version=\"2\">" << endl;
134     // Noeuds
135     if(minV!=maxV){
136       vector<int> puiss;
137       int i;
138       for(i=1;i<=nbNoeuds;++i){
139         int power=(int) (minV + (maxV - minV + 1.0) * rand() / (RAND_MAX + 1.0) );
140         puiss.push_back(power);
141       }
142       puiss[i = (rand() % nbNoeuds)] = maxV;                 // on force la présence des extremum
143       puiss[(i + ( rand() % nbNoeuds ) ) % nbNoeuds] = minV;
144       for(i=0;i<nbNoeuds;++i){
145         ficP << "  <host id=\"" << i+1 << "\" power=\"" << puiss[i] << "\"/>" << endl;
146       }
147       puiss.clear();      
148     }else{
149       for(int i=1;i<=nbNoeuds;++i){
150         ficP << "  <host id=\"" << i << "\" power=\"" << maxV << "\"/>" << endl;
151       }
152     }
153     // Liens
154     if(minB==maxB && minL==maxL && !liensDyns){ // liens identiques partout et statiques
155       ficP << "  <link id=\"unique\" bandwidth=\"" << maxB << "\" latency=\"" << minL << "\"/>" << endl;
156       lienUnique=true;
157     }else{
158       switch(topo){
159       case 'L':
160         genereLiensLigne(ficP, nbNoeuds, minB, maxB, minL, maxL, liensDyns, minP, maxP, intervalle);
161         break;
162       case 'A':
163         genereLiensAnneau(ficP, nbNoeuds, minB, maxB, minL, maxL, liensDyns, minP, maxP, intervalle);
164         break;
165       case 'C':
166         genereLiensComplet(ficP, nbNoeuds, minB, maxB, minL, maxL, liensDyns, minP, maxP, intervalle);
167         break;
168       }
169     }
170     // Routes
171     switch(topo){
172     case 'L':
173       genereRoutesLigne(ficP, nbNoeuds, lienUnique);
174       break;
175     case 'A':
176       genereRoutesAnneau(ficP, nbNoeuds, lienUnique);
177       break;
178     case 'C':
179       genereRoutesComplet(ficP, nbNoeuds, lienUnique);
180       break;
181     }
182     // Fin de description de plateforme
183     ficP << "</platform>" << endl;
184     // Fermeture du fichier
185     ficP.close();
186   }
187
188   // Génération du fichier de déploiement
189   switch(topo){
190   case 'L':
191     genereDeploiementLigne(nomFicD, nbNoeuds);
192     break;
193   case 'A':
194     genereDeploiementAnneau(nomFicD, nbNoeuds);
195     break;
196   case 'C':
197     genereDeploiementComplet(nomFicD, nbNoeuds);
198     break;
199   }
200   
201   return 0;
202 }
203
204 void aide(char *prog)
205 {
206   cout << "Usage : " << prog << " [options]" << endl
207        << "Options :" << endl
208        << "  -b entier  : bande passante min des liens" << endl
209        << "  -B entier  : bande passante max des liens" << endl
210        << "  -d         : liens dynamiques" << endl
211        << "  -D fichier : nom du fichier de déploiement" << endl
212        << "  -f réel    : durée min d'intermittence des liens" << endl
213        << "  -F réel    : durée max d'intermittence des liens" << endl
214        << "  -i réel    : intervalle de temps des intermittences des liens" << endl
215        << "  -l entier  : latence min des liens" << endl
216        << "  -L entier  : latence max des liens" << endl
217        << "  -n entier  : nombre de procs" << endl
218        << "  -P fichier : nom du fichier de plateforme" << endl
219        << "  -t car     : type de topologie (L, A, C)" << endl
220        << "  -v entier  : vitesse min des procs" << endl
221        << "  -V entier  : vitesse max des procs" << endl
222        << endl;
223 }
224
225 void genereLiensLigne(ofstream &fic, int nbNoeuds, int minB, int maxB, double minL, double maxL, bool liensDyns, double minP, double maxP, double intervalle)
226 {
227   ofstream ficState;
228   stringstream nom;
229
230   for(int i=1; i<nbNoeuds; ++i){
231     // Sens i -> i+1
232     fic << "  <link id=\"" << i << "-" << i+1 << "\"";
233     fic << " bandwidth=\"" << (int) (minB + (maxB - minB + 1.0) * rand() / (RAND_MAX + 1.0) ) << "\"";
234     fic << " latency=\"" << (minL + (maxL - minL) * rand() / RAND_MAX ) << "\"";
235     if(liensDyns){
236       // Spécification du fichier d'état dans la description du lien
237       nom.str("state_");
238       nom << i << "-" << i+1 << ".txt";
239       fic << " state_file=\"" << nom.str() << "\"";
240       // Écriture du fichier d'état
241       ficState.open(nom.str().c_str());
242       if(ficState.good()){
243         double somme=0.0;
244         bool etat = rand()%2;
245         ficState << "PERIODICITY " << (minP + (maxP - minP) * rand() / RAND_MAX ) << endl;
246         while(somme<intervalle){
247           double val = (minP + (maxP - minP) * rand() / RAND_MAX );
248           somme+=val;
249           ficState << somme << " " << ((etat==0)?1.0:-1.0) << endl;
250           etat = !etat;
251         }
252         ficState.close();
253       }
254     }
255     fic << "/>" << endl;
256     // Sens i+1 -> i
257     fic << "  <link id=\"" << i+1 << "-" << i << "\"";
258     fic << " bandwidth=\"" << (int) (minB + (maxB - minB + 1.0) * rand() / (RAND_MAX + 1.0) ) << "\"";
259     fic << " latency=\"" << (minL + (maxL - minL) * rand() / RAND_MAX ) << "\"";
260     if(liensDyns){
261       // Spécification du fichier d'état dans la description du lien
262       fic << " state_file=\"" << nom.str() << "\"";
263     }
264     fic << "/>" << endl;
265   }
266 }
267
268 void genereLiensAnneau(ofstream &fic, int nbNoeuds, int minB, int maxB, double minL, double maxL, bool liensDyns, double minP, double maxP, double intervalle)
269 {
270   ofstream ficState;
271   stringstream nom;
272
273   genereLiensLigne(fic, nbNoeuds, minB, maxB, minL, maxL, liensDyns, minP, maxP, intervalle);
274   // Sens dernier -> premier  
275   fic << "  <link id=\"" << nbNoeuds << "-" << 1 << "\"";
276   fic << " bandwidth=\"" << (int) (minB + (maxB - minB + 1.0) * rand() / (RAND_MAX + 1.0) ) << "\"";
277   fic << " latency=\"" << (minL + (maxL - minL) * rand() / RAND_MAX ) << "\"";
278   if(liensDyns){
279     // Spécification du fichier d'état dans la description du lien
280     nom.str("state_");
281     nom << nbNoeuds << "-" << 1 << ".txt";
282     fic << " state_file=\"" << nom.str() << "\"";
283     // Écriture du fichier d'état
284     ficState.open(nom.str().c_str());
285     if(ficState.good()){
286       double somme=0.0;
287       bool etat = rand()%2;
288       ficState << "PERIODICITY " << (minP + (maxP - minP) * rand() / RAND_MAX ) << endl;
289       while(somme<intervalle){
290         double val = (minP + (maxP - minP) * rand() / RAND_MAX );
291         somme+=val;
292         ficState << somme << " " << ((etat==0)?1.0:-1.0) << endl;
293         etat = !etat;
294       }
295       ficState.close();
296     }
297   }
298   fic << "/>" << endl;
299   // Sens premier -> dernier
300   fic << "  <link id=\"" << 1 << "-" << nbNoeuds << "\"";
301   fic << " bandwidth=\"" << (int) (minB + (maxB - minB + 1.0) * rand() / (RAND_MAX + 1.0) ) << "\"";
302   fic << " latency=\"" << (minL + (maxL - minL) * rand() / RAND_MAX ) << "\"";
303   if(liensDyns){
304     // Spécification du fichier d'état dans la description du lien
305     fic << " state_file=\"" << nom.str() << "\"";
306   }
307   fic << "/>" << endl;
308 }
309
310 void genereLiensComplet(ofstream &fic, int nbNoeuds, int minB, int maxB, double minL, double maxL, bool liensDyns, double minP, double maxP, double intervalle)
311 {
312   ofstream ficState;
313   stringstream nom;
314
315   for(int i=1; i<=nbNoeuds ; ++i){
316     for(int j=i+1; j<=nbNoeuds ; ++j){
317       // Sens i -> j
318       fic << "  <link id=\"" << i << "-" << j << "\"";
319       fic << " bandwidth=\"" << (int) (minB + (maxB - minB + 1.0) * rand() / (RAND_MAX + 1.0) ) << "\"";
320       fic << " latency=\"" << (minL + (maxL - minL) * rand() / RAND_MAX ) << "\"";
321       if(liensDyns){
322         // Spécification du fichier d'état dans la description du lien
323         nom.str("state_");
324         nom << i << "-" << j << ".txt";
325         fic << " state_file=\"" << nom.str() << "\"";
326         // Écriture du fichier d'état
327         ficState.open(nom.str().c_str());
328         if(ficState.good()){
329           double somme=0.0;
330           bool etat = rand()%2;
331           ficState << "PERIODICITY " << (minP + (maxP - minP) * rand() / RAND_MAX ) << endl;
332           while(somme<intervalle){
333             double val = (minP + (maxP - minP) * rand() / RAND_MAX );
334             somme+=val;
335             ficState << somme << " " << ((etat==0)?1.0:-1.0) << endl;
336             etat = !etat;
337           }
338           ficState.close();
339         }
340       }
341       fic << "/>" << endl;
342       // Sens j -> i
343       fic << "  <link id=\"" << j << "-" << i << "\"";
344       fic << " bandwidth=\"" << (int) (minB + (maxB - minB + 1.0) * rand() / (RAND_MAX + 1.0) ) << "\"";
345       fic << " latency=\"" << (minL + (maxL - minL) * rand() / RAND_MAX ) << "\"";
346       if(liensDyns){
347         // Spécification du fichier d'état dans la description du lien
348         fic << " state_file=\"" << nom.str() << "\"";
349       }
350       fic << "/>" << endl;
351     }
352   }
353 }
354
355 void genereRoutesLigne(ofstream &fic, int nbNoeuds, bool lienUnique)
356 {
357   for(int i=1; i<nbNoeuds; ++i){
358     // Sens i -> i+1
359     fic << "  <route src=\"" << i << "\" dst=\"" << i+1 << "\">" << endl;
360     if(lienUnique){
361       fic << "    <link:ctn id=\"unique\"/>" << endl;
362     }else{
363       fic << "    <link:ctn id=\"" << i << "-" << i+1 << "\"/>" << endl;
364     }
365     fic << "  </route>" << endl;
366     // Sens i+1 -> i
367     fic << "  <route src=\"" << i+1 << "\" dst=\"" << i << "\">" << endl;
368     if(lienUnique){
369       fic << "    <link:ctn id=\"unique\"/>" << endl;
370     }else{
371       fic << "    <link:ctn id=\"" << i+1 << "-" << i << "\"/>" << endl;
372     }
373     fic << "  </route>" << endl;
374   }
375 }
376
377 void genereRoutesAnneau(ofstream &fic, int nbNoeuds, bool lienUnique)
378 {
379   genereRoutesLigne(fic, nbNoeuds, lienUnique);
380   // Sens dernier -> premier  
381   fic << "  <route src=\"" << nbNoeuds << "\" dst=\"" << 1 << "\">" << endl;
382   if(lienUnique){
383     fic << "    <link:ctn id=\"unique\"/>" << endl;
384   }else{
385     fic << "    <link:ctn id=\"" << nbNoeuds << "-" << 1 << "\"/>" << endl;
386   }
387   fic << "  </route>" << endl;
388   // Sens premier -> dernier
389   fic << "  <route src=\"" << 1 << "\" dst=\"" << nbNoeuds << "\">" << endl;
390   if(lienUnique){
391     fic << "    <link:ctn id=\"unique\"/>" << endl;
392   }else{
393     fic << "    <link:ctn id=\"" << 1 << "-" << nbNoeuds << "\"/>" << endl;
394   }
395   fic << "  </route>" << endl;
396 }
397
398 void genereRoutesComplet(ofstream &fic, int nbNoeuds, bool lienUnique)
399 {
400   for(int i=1; i<=nbNoeuds ; ++i){
401     for(int j=i+1; j<=nbNoeuds ; ++j){
402       // Sens i -> j
403       fic << "  <route src=\"" << i << "\" dst=\"" << j << "\">" << endl;
404       if(lienUnique){
405         fic << "    <link:ctn id=\"unique\"/>" << endl;
406       }else{
407         fic << "    <link:ctn id=\"" << i << "-" << j << "\"/>" << endl;
408       }
409       fic << "  </route>" << endl;
410       // Sens j -> i
411       fic << "  <route src=\"" << j << "\" dst=\"" << i << "\">" << endl;
412       if(lienUnique){
413         fic << "    <link:ctn id=\"unique\"/>" << endl;
414       }else{
415         fic << "    <link:ctn id=\"" << j << "-" << i << "\"/>" << endl;
416       }
417       fic << "  </route>" << endl;
418     }
419   }
420 }
421
422 void genereDeploiementLigne(string &nom, int nbNoeuds)
423 {
424   ofstream fic;
425   
426   fic.open(nom.c_str());
427   if(fic.good()){
428     fic << "<?xml version='1.0'?>" << endl;
429     fic << "<!DOCTYPE platform SYSTEM \"simgrid.dtd\">" << endl;
430     fic << "<platform version=\"2\">" << endl;
431     for(int i=1; i<=nbNoeuds; ++i){
432       // Dépendances du proc i
433       fic << "  <process host=\"" << i << "\" function=\"Calculs\">" << endl;
434       if(i>1)
435         fic << "    <argument value=\"" << i-1 << "\"/>" << endl;
436       if(i<nbNoeuds)
437         fic << "    <argument value=\"" << i+1 << "\"/>" << endl;
438       fic << "  </process>" << endl;
439     }
440     fic << "</platform>" << endl;
441     fic.close();
442   }else{
443     cout << "Problème d'écriture du fichier de déploiement !" << endl;
444   }
445 }
446
447 void genereDeploiementAnneau(string &nom, int nbNoeuds)
448 {
449   ofstream fic;
450   
451   fic.open(nom.c_str());
452   if(fic.good()){
453     fic << "<?xml version='1.0'?>" << endl;
454     fic << "<!DOCTYPE platform SYSTEM \"simgrid.dtd\">" << endl;
455     fic << "<platform version=\"2\">" << endl;
456     for(int i=1; i<=nbNoeuds; ++i){
457       // Dépendances du proc i
458       fic << "  <process host=\"" << i << "\" function=\"Calculs\">" << endl;
459       fic << "    <argument value=\"" << 1+(i-1+nbNoeuds-1)%nbNoeuds << "\"/>" << endl;
460       fic << "    <argument value=\"" << 1+(i%nbNoeuds) << "\"/>" << endl;
461       fic << "  </process>" << endl;
462     }
463     fic << "</platform>" << endl;
464     fic.close();
465   }else{
466     cout << "Problème d'écriture du fichier de déploiement !" << endl;
467   }
468 }
469
470 void genereDeploiementComplet(string &nom, int nbNoeuds)
471 {
472   ofstream fic;
473   
474   fic.open(nom.c_str());
475   if(fic.good()){
476     fic << "<?xml version='1.0'?>" << endl;
477     fic << "<!DOCTYPE platform SYSTEM \"simgrid.dtd\">" << endl;
478     fic << "<platform version=\"2\">" << endl;
479     for(int i=1; i<=nbNoeuds; ++i){
480       // Dépendances du proc i
481       fic << "  <process host=\"" << i << "\" function=\"Calculs\">" << endl;
482       for(int j=1; j<=nbNoeuds; ++j){
483         if(i!=j)
484           fic << "    <argument value=\"" << j << "\"/>" << endl;
485       }
486       fic << "  </process>" << endl;
487     }
488     fic << "</platform>" << endl;
489     fic.close();
490   }else{
491     cout << "Problème d'écriture du fichier de déploiement !" << endl;
492   }
493 }