X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/loba.git/blobdiff_plain/9c6f9565824d2cc3389e87f13ee9a0308d615807..b0b2d9cb57d83fcdfb92837561ffb5dbab288323:/deployment.cpp diff --git a/deployment.cpp b/deployment.cpp index db02f0d..f34c3a9 100644 --- a/deployment.cpp +++ b/deployment.cpp @@ -1,9 +1,235 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(depl); + +#include "hostdata.h" +#include "misc.h" +#include "options.h" + #include "deployment.h" -namespace { +void MY_launch_application() +{ + deployment_generator* gen; + gen = opt::topologies.new_instance(opt::auto_depl::topology); + gen->generate(); + gen->distribute_load(); + gen->deploy(); + delete gen; +} + +deployment_generator::deployment_generator() + : hosts(opt::auto_depl::nhosts) +{ +} +void deployment_generator::set_load(int host, double load) +{ + hosts[host].load = load; } -void MY_launch_application() +void deployment_generator::set_neighbor(int host, int neighbor) +{ + hosts[host].neighbors.push_back(neighbor); +} + +void deployment_generator::set_link(int host1, int host2) +{ + set_neighbor(host1, host2); + set_neighbor(host2, host1); +} + +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 loads(hosts.size()); + std::generate(loads.begin(), loads.end(), drand48); + 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(), _1, factor)); + if (opt::integer_transfer) { + double iload; + double residue = 0.0; + unsigned i; + 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(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); + for (unsigned i = 0 ; i < hosts.size() ; ++i) { + const char* hostname = hostdata::at(i).get_name(); + std::ostringstream oss; + oss << std::setprecision(12) << hosts[i].load; + std::string strload = oss.str(); + XBT_DEBUG("%s/load -> \"%s\"", hostname, strload.c_str()); + xbt_dynar_push_as(args, const char*, strload.c_str()); + for (unsigned j = 0 ; j < hosts[i].neighbors.size() ; ++j) { + int neighbor = hosts[i].neighbors[j]; + const char* neighbor_name = hostdata::at(neighbor).get_name(); + XBT_DEBUG("%s/neighbor -> \"%s\"", hostname, neighbor_name); + xbt_dynar_push_as(args, const char*, neighbor_name); + } + MSG_set_function(hostname, "compute", args); + xbt_dynar_reset(args); + } + xbt_dynar_free(&args); +} + +void deployment_btree::generate() { + for (unsigned i = 0 ; i < size() / 2 ; ++i) { + unsigned left_child = 2 * i + 1; + unsigned right_child = 2 * i + 2; + if (left_child < size()) { + set_link(i, left_child); + if (right_child < size()) + set_link(i, right_child); + } + } +} + +void deployment_clique::generate() +{ + for (unsigned i = 0 ; i < size() ; ++i) + for (unsigned j = 0 ; j < i ; ++j) + set_link(i, j); +} + +void deployment_hcube::generate() +{ + for (unsigned i = 0 ; i < size() ; ++i) + for (unsigned j = 0 ; j < i ; ++j) { + // Adapted from rom http://en.wikipedia.org/wiki/Hamming_distance + unsigned dist = 0; + unsigned val = i ^ j; + + // Count the number of set bits + while (val && dist < 2) { + ++dist; + val &= val - 1; + } + if (dist == 1) + set_link(i, j); + } +} + +void deployment_line::generate() +{ + for (unsigned i = 0 ; i < size() - 1 ; ++i) + set_link(i, i + 1); +} + +void deployment_ring::generate() +{ + set_neighbor(0, size() - 1); + for (unsigned i = 0 ; i < size() - 1 ; ++i) + set_link(i, i + 1); + set_neighbor(size() - 1, 0); +} + +void deployment_star::generate() +{ + for (unsigned i = 1 ; i < size() ; ++i) + set_link(0, i); +} + +void deployment_torus::generate() +{ + unsigned a = 0; + unsigned b = size(); + while (a + 1 < b) { + unsigned c = (a + b) / 2; + if (c * c < size()) + a = c; + else + b = c; + } + unsigned width = b; + // 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", + size(), width, size() / width + !!(size() % width), + first_on_last_line); + for (unsigned i = 0; i < size(); i++) { + unsigned next_line; + unsigned prev_line; + unsigned next_column; + unsigned prev_column; + + next_line = i + width; + if (next_line >= size()) + next_line %= width; // rewind + + if (i >= width) { + prev_line = i - width; + } else { + prev_line = first_on_last_line + i; // rewind + if (prev_line >= size()) + prev_line -= width; // need to go at last but one line + } + + if (i != size() - 1) { + next_column = i + 1; + if (next_column % width == 0) + next_column -= width; // rewind + } else { + next_column = first_on_last_line; // special case for last cell + } + + if (i % width != 0) { + prev_column = i - 1; + } else if (i < first_on_last_line) { + prev_column = i + width - 1; // rewind + } else { + prev_column = size() - 1; // special case for 1st cell of last line + } + if (next_line != i) { + set_neighbor(i, next_line); + if (prev_line != next_line) + set_neighbor(i, prev_line); + } + if (next_column != i) { + set_neighbor(i, next_column); + if (prev_column != next_column) + set_neighbor(i, prev_column); + } + } }