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 }