#include <algorithm>
+#include <cmath>
#include <cstdlib>
-#include <functional>
#include <iomanip>
#include <numeric>
#include <sstream>
#include <vector>
-#include <msg/msg.h>
+#include <simgrid/msg.h>
#include <xbt/dynar.h>
#include <xbt/log.h>
void deployment_generator::distribute_load()
{
- using std::placeholders::_1;
-
if (!opt::auto_depl::random_distribution) {
set_load(0, opt::auto_depl::load);
return;
}
- srand48(opt::auto_depl::random_seed);
std::vector<double> loads(hosts.size());
- std::generate(loads.begin(), loads.end(), drand48);
+ if (opt::auto_depl::random_seed != 1) {
+ srand48(opt::auto_depl::random_seed);
+ std::generate(loads.begin(), loads.end(), drand48);
+ } else {
+ std::fill(loads.begin(), loads.end(), 1.0);
+ }
double factor = opt::auto_depl::load /
std::accumulate(loads.begin(), loads.end(), 0.0);
std::transform(loads.begin(), loads.end(), loads.begin(),
- std::bind(std::multiplies<double>(), _1, factor));
+ [&factor](double a) { return factor * a; });
if (opt::integer_transfer) {
- // round the loads
- std::vector<double> iloads(hosts.size());
- std::transform(loads.begin(), loads.end(), iloads.begin(), round);
- // compute the differences between each load and its rounded value
- std::vector<double> diffs(hosts.size());
- std::transform(loads.begin(), loads.end(), iloads.begin(),
- diffs.begin(), std::minus<double>());
- // compute the absolute values of the diffs
- std::vector<double> adiffs(hosts.size());
- std::transform(diffs.begin(), diffs.end(), adiffs.begin(), fabs);
- // find i, index of the element farthest from its rounded value
+ double iload;
+ double residue = 0.0;
unsigned i;
- i = std::max_element(adiffs.begin(), adiffs.end()) - adiffs.begin();
- // remove element i from diffs, and compute the residual part...
- diffs[i] = diffs.back();
- diffs.pop_back();
- double residue = std::accumulate(diffs.begin(), diffs.end(), 0.0);
- // ... and compute element i (rounded to avoid numerical errors)
- iloads[i] = fabs(round(loads[i] + residue));
+ for (i = 0 ; i < hosts.size() - 1; ++i) {
+ if (residue < 0.0)
+ iload = std::floor(loads[i]);
+ else if (residue > 0.0)
+ iload = std::ceil(loads[i]);
+ else // residue == 0.0
+ iload = std::round(loads[i]);
+ residue += (loads[i] - iload);
+ loads[i] = iload;
+ }
+ // abs(round(...)) to avoid rounding errors, or a value of -0
+ // Note: i == hosts.size() - 1
+ iload = std::abs(std::round(loads[i] + residue));
+ loads[i] = iload;
// final sanity check
xbt_assert(opt::auto_depl::load ==
- std::accumulate(iloads.begin(), iloads.end(), 0.0));
- for (unsigned i = 0 ; i < hosts.size() ; ++i)
- set_load(i, iloads[i]);
- } else {
- for (unsigned i = 0 ; i < hosts.size() ; ++i)
- set_load(i, loads[i]);
+ std::accumulate(loads.begin(), loads.end(), 0.0));
}
+ for (unsigned i = 0 ; i < hosts.size() ; ++i)
+ set_load(i, loads[i]);
}
void deployment_generator::deploy()
{
- xbt_dynar_t args = xbt_dynar_new(sizeof(const char*), NULL);
+ xbt_dynar_t args = xbt_dynar_new(sizeof(const char*), nullptr);
for (unsigned i = 0 ; i < hosts.size() ; ++i) {
const char* hostname = hostdata::at(i).get_name();
std::ostringstream oss;
b = c;
}
unsigned width = b;
- // here width == ceil(sqrt(size))
+ // here width == std::ceil(std::sqrt(size))
unsigned first_on_last_line = (size() - 1) - (size() - 1) % width;
XBT_DEBUG("torus size = %zu ; width = %u ; height = %zu ; foll = %u",