Add options to control min./max. data transfer amount.

[loba.git] / options.cpp

diff --git a/options.cpp b/options.cpp
index 107b1804344804456951be5d7131611ae45124c6..9f7ea5c0a6b3a8cdc512c6623d99495d4c8c880f 100644 (file)
--- a/options.cpp
+++ b/options.cpp
@@ -48,11 +48,15 @@ namespace opt {
     std::string loba_algo("simple");
     bool bookkeeping = false;
     double min_lb_iter_duration = 1.0;          // fixme: find better defaults
     std::string loba_algo("simple");
     bool bookkeeping = false;
     double min_lb_iter_duration = 1.0;          // fixme: find better defaults

+    double min_transfer_amount = 0.0;
+    double max_transfer_amount = 0.0;

 
     // Application parameters
     cost_func comp_cost("1e9, 0");              // fixme: find better defaults
     cost_func comm_cost("1e6, 0");              // fixme: find better defaults
     double min_comp_iter_duration = 1.0;        // fixme: find better defaults
 
     // Application parameters
     cost_func comp_cost("1e9, 0");              // fixme: find better defaults
     cost_func comm_cost("1e6, 0");              // fixme: find better defaults
     double min_comp_iter_duration = 1.0;        // fixme: find better defaults

+    unsigned comp_iter_delay = 0;               // fixme: find better defaults
+    double comp_time_delay = 0.0;               // fixme: find better defaults

 
     // Parameters for the end of the simulation
     unsigned lb_maxiter = 0;
 
     // Parameters for the end of the simulation
     unsigned lb_maxiter = 0;


@@ -64,10 +68,14 @@ namespace opt {
     loba_algorithms_type loba_algorithms;
     loba_algorithms_type::loba_algorithms_type()
     {
     loba_algorithms_type loba_algorithms;
     loba_algorithms_type::loba_algorithms_type()
     {

-        NOL_INSERT("fairstrategy", "balance with fair strategy", loba_fairstrategy);
-        NOL_INSERT("makhoul", "balance with Makhoul's PhD algorithm", loba_makhoul);
-        NOL_INSERT("none", "no load-balancing (for testing only)", process);
-        NOL_INSERT("simple", "balance with least loaded neighbor", loba_simple);
+        NOL_INSERT("fairstrategy", "balance with fair strategy",
+                   loba_fairstrategy);
+        NOL_INSERT("makhoul", "balance with Makhoul's PhD algorithm",
+                   loba_makhoul);
+        NOL_INSERT("none", "no load-balancing (for testing only)",
+                   process);
+        NOL_INSERT("simple", "balance with least loaded neighbor",
+                   loba_simple);

     }
 
     topologies_type topologies;
     }
 
     topologies_type topologies;


@@ -194,7 +202,8 @@ bool opt::parse_args(int* argc, char* argv[])
     
     int c;
     opterr = 0;
     
     int c;
     opterr = 0;

-    while ((c = getopt(*argc, argv, "a:bc:C:ehi:I:l:L:N:s:S:t:T:vV")) != -1) {
+    while ((c = getopt(*argc, argv,
+                       "a:bc:C:d:D:ehi:I:l:L:m:M:N:s:S:t:T:vV")) != -1) {

         switch (c) {
         case 'a':
             opt::loba_algo = optarg;
         switch (c) {
         case 'a':
             opt::loba_algo = optarg;


@@ -216,7 +225,8 @@ bool opt::parse_args(int* argc, char* argv[])
             try {
                 opt::comp_cost = cost_func(optarg);
             } catch (...) {
             try {
                 opt::comp_cost = cost_func(optarg);
             } catch (...) {

-                XBT_ERROR("invalid argument for option '-%c' -- \"%s\"", c, optarg);
+                XBT_ERROR("invalid argument for option '-%c' -- \"%s\"",
+                          c, optarg);

                 result = false;
             }
             break;
                 result = false;
             }
             break;


@@ -224,10 +234,17 @@ bool opt::parse_args(int* argc, char* argv[])
             try {
                 opt::comm_cost = cost_func(optarg);
             } catch (...) {
             try {
                 opt::comm_cost = cost_func(optarg);
             } catch (...) {

-                XBT_ERROR("invalid argument for option '-%c' -- \"%s\"", c, optarg);
+                XBT_ERROR("invalid argument for option '-%c' -- \"%s\"",
+                          c, optarg);

                 result = false;
             }
             break;
                 result = false;
             }
             break;

+        case 'd':
+            PARSE_ARG(opt::comp_iter_delay);
+            break;
+        case 'D':
+            PARSE_ARG(opt::comp_time_delay);
+            break;

         case 'i':
             PARSE_ARG(opt::lb_maxiter);
             break;
         case 'i':
             PARSE_ARG(opt::lb_maxiter);
             break;


@@ -240,6 +257,12 @@ bool opt::parse_args(int* argc, char* argv[])
         case 'L':
             PARSE_ARG(opt::auto_depl::load);
             break;
         case 'L':
             PARSE_ARG(opt::auto_depl::load);
             break;

+        case 'm':
+            PARSE_ARG(opt::min_transfer_amount);
+            break;
+        case 'M':
+            PARSE_ARG(opt::max_transfer_amount);
+            break;

         case 'N':
             PARSE_ARG(opt::auto_depl::nhosts);
             break;
         case 'N':
             PARSE_ARG(opt::auto_depl::nhosts);
             break;


@@ -293,6 +316,12 @@ bool opt::parse_args(int* argc, char* argv[])
         result = false;
     }
 
         result = false;
     }
 

+    if (opt::max_transfer_amount &&
+        opt::max_transfer_amount < opt::min_transfer_amount) {
+        XBT_ERROR("max. data transfer amount < min. data transfer amount");
+        result = false;
+    }
+

     return result;
 }
 
     return result;
 }
 


@@ -318,10 +347,16 @@ void opt::print()
     }
     DESCR("load balancing algorithm", "%s", loba_algo.c_str());
     DESCR("bookkeeping", "%s", h.on_off(bookkeeping));
     }
     DESCR("load balancing algorithm", "%s", loba_algo.c_str());
     DESCR("bookkeeping", "%s", h.on_off(bookkeeping));

-    DESCR("minimum duration between lb. iterations", "%g", min_lb_iter_duration);
+    DESCR("minimum duration between lb. iterations", "%g",
+          min_lb_iter_duration);

     DESCR("computation cost factors", "[%s]", comp_cost.to_string().c_str());
     DESCR("communication cost factors", "[%s]", comm_cost.to_string().c_str());
     DESCR("computation cost factors", "[%s]", comp_cost.to_string().c_str());
     DESCR("communication cost factors", "[%s]", comm_cost.to_string().c_str());

-    DESCR("minimum duration between comp. iterations", "%g", min_comp_iter_duration);
+    DESCR("minimum data transfer amount", "%g", min_transfer_amount);
+    DESCR("maximum data transfer amount", "%g", max_transfer_amount);
+    DESCR("minimum duration between comp. iterations", "%g",
+          min_comp_iter_duration);
+    DESCR("computations start after lb. iter", "%u", comp_iter_delay);
+    DESCR("computations start after time", "%g", comp_time_delay);

     DESCR("maximum number of lb. iterations", "%s",
           h.val_or_string(lb_maxiter, "infinity"));
     DESCR("maximum number of comp. iterations", "%s",
     DESCR("maximum number of lb. iterations", "%s",
           h.val_or_string(lb_maxiter, "infinity"));
     DESCR("maximum number of comp. iterations", "%s",


@@ -399,9 +434,21 @@ void opt::usage()
     std::clog << o("-C [aN,...]a0")
               << "polynomial factors for communication cost"
               << " [" << opt::comm_cost.to_string() << "]\n";
     std::clog << o("-C [aN,...]a0")
               << "polynomial factors for communication cost"
               << " [" << opt::comm_cost.to_string() << "]\n";

+    std::clog << o("-m value")
+              << "minimum data transfer amount"
+              << " [" << opt::min_transfer_amount << "]\n";
+    std::clog << o("-M value")
+              << "maximum data transfer amount (0 for no limit)"
+              << " [" << opt::max_transfer_amount << "]\n";

     std::clog << o("-S value")
               << "minimum duration between comp. iterations"
               << " [" << opt::min_comp_iter_duration << "]\n";
     std::clog << o("-S value")
               << "minimum duration between comp. iterations"
               << " [" << opt::min_comp_iter_duration << "]\n";

+    std::clog << o("-d value")
+              << "start computations after given number of lb iterations"
+              << " [" << opt::comp_iter_delay << "]\n";
+    std::clog << o("-D value")
+              << "start computations after given time"
+              << " [" << opt::comp_time_delay << "]\n";

 
     std::clog << "\nParameters for the end of the simulation\n";
     std::clog << o("-i value")
 
     std::clog << "\nParameters for the end of the simulation\n";
     std::clog << o("-i value")