options.cpp

   1 #include "options.h"
   2
   3 #include <iomanip>
   4 #include <iostream>
   5 #include <sstream>
   6 #include <unistd.h>             // getopt
   7 #include <xbt/log.h>
   8 #include "loba_simple.h"
   9
  10 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(main);
  11
  12 namespace opt {
  13
  14     // Global options
  15     std::string program_name;
  16     int help_requested = 0;
  17     bool version_requested = false;
  18
  19     // Simulation parameters
  20     unsigned log_rate = 1;
  21
  22     // Platform and deployment
  23     std::string platform_file;
  24     std::string deployment_file;
  25
  26     // Automatic deployment
  27     namespace auto_depl {
  28         bool        enabled = false;
  29         std::string topology;
  30         unsigned    nhosts = 0;
  31         double      load = 0.0;
  32     }
  33
  34     // Load balancing algorithm
  35     std::string loba_algo("none");
  36     bool bookkeeping = false;
  37
  38     // Application parameters
  39     cost_func comp_cost("1e9, 0"); // fixme: find better defaults
  40     cost_func comm_cost("1, 0"); // fixme: find better defaults
  41     unsigned maxiter = 4;       // fixme
  42     bool exit_on_close = false;
  43
  44     // Named parameters lists
  45     loba_algorithms_type loba_algorithms;
  46     loba_algorithms_type::loba_algorithms_type()
  47     {
  48         THIS_INSERT("none", "no load-balancing", process);
  49         THIS_INSERT("simple", "balance with least loaded neighbor",
  50                     loba_simple);
  51     }
  52
  53 #if 0
  54     topologies_type topologies;
  55     topologies_type::topologies_type()
  56     {
  57         THIS_INSERT("none", "no load-balancing", process);
  58         THIS_INSERT("simple", "balance with least loaded neighbor",
  59                     loba_simple);
  60     }
  61 #endif
  62
  63 } // namespace opt
  64
  65 namespace {
  66
  67     const char* on_off(bool b)
  68     {
  69         return b ? "on" : "off";
  70     }
  71
  72 }
  73
  74 int opt::parse_args(int* argc, char* argv[])
  75 {
  76     int result = 1;
  77
  78     opt::program_name = argv[0];
  79     opt::program_name.erase(0, 1 + opt::program_name.find_last_of('/'));
  80
  81     int c;
  82     opterr = 0;
  83     while ((c = getopt(*argc, argv, "a:bc:C:ehi:l:L:N:T:V")) != -1) {
  84         switch (c) {
  85         case 'a':
  86             opt::loba_algo = optarg;
  87             break;
  88         case 'b':
  89             opt::bookkeeping = true;
  90             break;
  91         case 'e':
  92             opt::exit_on_close = true;
  93             break;
  94         case 'h':
  95             opt::help_requested++;
  96             break;
  97         case 'c':
  98             opt::comp_cost = cost_func(optarg);
  99             break;
 100         case 'C':
 101             opt::comm_cost = cost_func(optarg);
 102             break;
 103         case 'i':
 104             std::istringstream(optarg) >> opt::maxiter;
 105             break;
 106         case 'l':
 107             std::istringstream(optarg) >> opt::log_rate;
 108             break;
 109         case 'L':
 110             std::istringstream(optarg) >> opt::auto_depl::load;
 111             break;
 112         case 'N':
 113             std::istringstream(optarg) >> opt::auto_depl::nhosts;
 114             break;
 115         case 'T':
 116             opt::auto_depl::topology = optarg;
 117             break;
 118         case 'V':
 119             opt::version_requested = true;
 120             break;
 121         case '?':
 122             ERROR1("invalid option -- '%c'", optopt);
 123             result = 0;
 124             break;
 125         }
 126     }
 127     opt::auto_depl::enabled = !opt::auto_depl::topology.empty();
 128
 129     if (opt::version_requested || opt::help_requested)
 130         return 1;
 131
 132     if (optind < *argc) {
 133         opt::platform_file = argv[optind++];
 134     } else {
 135         ERROR0("missing parameter -- <plaform_file>");
 136         result = 0;
 137     }
 138     if (!opt::auto_depl::enabled) {
 139         if (optind < *argc) {
 140             opt::deployment_file = argv[optind++];
 141         } else {
 142             ERROR0("missing parameter -- <deployment_file>");
 143             result = 0;
 144         }
 145     }
 146
 147     while (optind < *argc) {
 148         ERROR1("unused parameter -- \"%s\"", argv[optind++]);
 149         result = 0;
 150     }
 151
 152     return result;
 153 }
 154
 155 void opt::print()
 156 {
 157     INFO0(",----[ Simulation parameters ]");
 158     INFO1("| platform file.......: \"%s\"", opt::platform_file.c_str());
 159     if (opt::auto_depl::enabled) {
 160         INFO0("| automatic deployment enabled with:");
 161         INFO1("|     topology........: %s", opt::auto_depl::topology.c_str());
 162         INFO1("|     number of hosts.: %u", opt::auto_depl::nhosts);
 163         INFO1("|     initial load....: %g", opt::auto_depl::load);
 164     } else {
 165         INFO1("| deployment file.....: \"%s\"", opt::deployment_file.c_str());
 166     }
 167     INFO1("| log rate............: %u",     opt::log_rate);
 168     INFO1("| maxiter.............: %u",     opt::maxiter);
 169     INFO1("| exit on close.......: %s",     on_off(opt::exit_on_close));
 170     INFO1("| bookkeeping.........: %s",     on_off(opt::bookkeeping));
 171     INFO1("| comp. cost factors..: [%s]",   opt::comp_cost.to_string().c_str());
 172     INFO1("| comm. cost factors..: [%s]",   opt::comm_cost.to_string().c_str());
 173     INFO0("`----");
 174 }
 175
 176 void opt::usage()
 177 {
 178     // option(...)
 179 #define o(opt) "    " << std::setw(14) \
 180                       << std::left << (opt) << std::right << " "
 181     // sub-option(...)
 182 #define so(subopt) std::setw(18) << (subopt) << " : "
 183     // sub-option list
 184 #define so_list(name) do {                                      \
 185         name ## _type::iterator it;                             \
 186         for (it = name.begin() ; it != name.end() ; ++it)       \
 187             std::clog << so(name.get_name(it))                  \
 188                       << name.get_descr(it) << "\n";            \
 189     } while (0)
 190
 191
 192     std::clog << "Usage: " << opt::program_name
 193               << " [options] <platform_file> <deployment_file>\n";
 194     std::clog << "       " << opt::program_name
 195               << " [options] -T type <platform_file>\n";
 196
 197     std::clog << "\nGlobal options\n";
 198     std::clog << o("-h")
 199               << "print help and exit (use -hh for extended help)\n";
 200     if (opt::help_requested < 1)
 201         return;
 202
 203     std::clog << o("--help") << "print help from SimGrid framework and exit\n";
 204     std::clog << o("-V") << "print version and exit\n";
 205
 206     std::clog << "\nSimulation parameters\n";
 207     std::clog << o("-l value")
 208               << "print current load every n-th iterations, 0 to disable"
 209               << " (" << opt::log_rate << ")\n";
 210
 211     std::clog << "\nAutomatic deployment options\n";
 212     std::clog << o("-T name")
 213               << "enable automatic deployment with selected topology\n";
 214     if (opt::help_requested > 1)
 215 #if 0
 216         so_list(opt::topologies);
 217 #else
 218         std::clog << so("name") << "FIXME\n"; // fixme
 219 #endif
 220     std::clog << o("-L value")
 221               << "total load with auto deployment, 0 for number of hosts"
 222               << " (" << opt::auto_depl::load << ")\n";
 223     std::clog << o("-N value")
 224               << "number of hosts to use with auto deployment,"
 225               << " 0 for max. (" << opt::auto_depl::nhosts << ")\n";
 226
 227     std::clog << "\nLoad balancing algorithm\n";
 228     std::clog << o("-a name") << "load balancing algorithm"
 229               << " (" << opt::loba_algo << ")\n";
 230     if (opt::help_requested > 1)
 231         so_list(opt::loba_algorithms);
 232     std::clog << o("-b") << "enable bookkeeping\n";
 233
 234     std::clog << "\nApplication parameters\n";
 235     std::clog << o("-c [fn,...]f0")
 236               << "polynomial factors for computation cost"
 237               << " (" << opt::comp_cost.to_string() << ")\n";
 238     std::clog << o("-C [fn,...]f0")
 239               << "polynomial factors for communication cost"
 240               << " (" << opt::comm_cost.to_string() << ")\n";
 241     std::clog << o("-e") << "exit on reception of \"close\" message\n";
 242     std::clog << o("-i value")
 243               << "maximum number of iterations, 0 for infinity"
 244               << " (" << opt::maxiter << ")\n";
 245
 246 #undef so_list
 247 #undef so
 248 #undef o
 249 }
 250
 251 // Local variables:
 252 // mode: c++
 253 // End: