std::vector<sg4::Exec*> ready_tasks;
std::map<sg4::Exec*, unsigned int> candidate_execs;
- for (auto& a : dax) {
+ for (const auto& a : dax) {
// Only look at activity that have their dependencies solved but are not assigned
if (a->dependencies_solved() && not a->is_assigned()) {
// if it is an exec, it's ready
return ready_tasks;
}
-static double finish_on_at(const sg4::ExecPtr task, const sg4::Host* host)
+static sg4::Host* get_best_host(const sg4::ExecPtr exec, double* min_finish_time)
{
- double data_available = 0.;
- double last_data_available = -1.0;
- /* compute last_data_available */
- for (const auto& parent : task->get_dependencies()) {
- /* normal case */
- if (const auto* comm = dynamic_cast<sg4::Comm*>(parent.get())) {
- auto source = comm->get_source();
- XBT_DEBUG("transfer from %s to %s", source->get_cname(), host->get_cname());
- /* Estimate the redistribution time from this parent */
- double redist_time;
- if (comm->get_remaining() <= 1e-6) {
- redist_time = 0;
- } else {
- double bandwidth = std::numeric_limits<double>::max();
- auto [links, latency] = source->route_to(host);
- for (auto const& link : links)
- bandwidth = std::min(bandwidth, link->get_bandwidth());
-
- redist_time = latency + comm->get_remaining() / bandwidth;
+ sg4::Host* best_host = nullptr;
+ *min_finish_time = std::numeric_limits<double>::max();
+
+ for (const auto& host : sg4::Engine::get_instance()->get_all_hosts()) {
+ double data_available = 0.;
+ double last_data_available = -1.0;
+ /* compute last_data_available */
+ for (const auto& parent : exec->get_dependencies()) {
+ /* normal case */
+ if (const auto* comm = dynamic_cast<sg4::Comm*>(parent.get())) {
+ const auto* source = comm->get_source();
+ XBT_DEBUG("transfer from %s to %s", source->get_cname(), host->get_cname());
+ /* Estimate the redistribution time from this parent */
+ double redist_time;
+ if (comm->get_remaining() <= 1e-6) {
+ redist_time = 0;
+ } else {
+ double bandwidth = std::numeric_limits<double>::max();
+ auto [links, latency] = source->route_to(host);
+ for (auto const& link : links)
+ bandwidth = std::min(bandwidth, link->get_bandwidth());
+
+ redist_time = latency + comm->get_remaining() / bandwidth;
+ }
+ // We use the user data field to store the finish time of the predecessor of the comm, i.e., its potential
+ // start time
+ data_available = *comm->get_data<double>() + redist_time;
}
- // We use the user data field to store the finish time of the predecessor of the comm, i.e., its potential start
- // time
- data_available = *comm->get_data<double>() + redist_time;
- }
- /* no transfer, control dependency */
- if (const auto* exec = dynamic_cast<sg4::Exec*>(parent.get()))
- data_available = exec->get_finish_time();
+ /* no transfer, control dependency */
+ if (const auto* parent_exec = dynamic_cast<sg4::Exec*>(parent.get()))
+ data_available = parent_exec->get_finish_time();
- if (last_data_available < data_available)
- last_data_available = data_available;
- }
- return std::max(*host->get_data<double>(), last_data_available) + task->get_remaining() / host->get_speed();
-}
+ if (last_data_available < data_available)
+ last_data_available = data_available;
+ }
-static sg4::Host* get_best_host(const sg4::ExecPtr exec)
-{
- sg4::Host* best_host;
- double min_EFT = std::numeric_limits<double>::max();
+ double finish_time = std::max(*host->get_data<double>(), last_data_available) +
+ exec->get_remaining() / host->get_speed();
- for (const auto& host : sg4::Engine::get_instance()->get_all_hosts()) {
- double EFT = finish_on_at(exec, host);
- XBT_DEBUG("%s finishes on %s at %f", exec->get_cname(), host->get_cname(), EFT);
+ XBT_DEBUG("%s finishes on %s at %f", exec->get_cname(), host->get_cname(), finish_time);
- if (EFT < min_EFT) {
- min_EFT = EFT;
- best_host = host;
+ if (finish_time < *min_finish_time) {
+ *min_finish_time = finish_time;
+ best_host = host;
}
}
+
return best_host;
}
std::set<sg4::Activity*> vetoed;
e.track_vetoed_activities(&vetoed);
- sg4::Activity::on_completion_cb([](sg4::Activity const& activity) {
+ sg4::Exec::on_completion_cb([](sg4::Exec const& exec) {
// when an Exec completes, we need to set the potential start time of all its ouput comms
- const auto* exec = dynamic_cast<sg4::Exec const*>(&activity);
- if (exec == nullptr) // Only Execs are concerned here
- return;
- for (const auto& succ : exec->get_successors()) {
+ for (const auto& succ : exec.get_successors()) {
auto* comm = dynamic_cast<sg4::Comm*>(succ.get());
if (comm != nullptr) {
- auto* finish_time = new double(exec->get_finish_time());
+ auto* finish_time = new double(exec.get_finish_time());
// We use the user data field to store the finish time of the predecessor of the comm, i.e., its potential start
// time
comm->set_data(finish_time);
auto dax = sg4::create_DAG_from_DAX(argv[2]);
/* Schedule the root first */
+ double root_finish_time;
auto* root = static_cast<sg4::Exec*>(dax.front().get());
- auto host = get_best_host(root);
+ auto* host = get_best_host(root, &root_finish_time);
schedule_on(root, host);
e.run();
vetoed.clear();
if (ready_tasks.empty()) {
- /* there is no ready task, let advance the simulation */
+ /* there is no ready exec, let advance the simulation */
e.run();
continue;
}
- /* For each ready task:
+ /* For each ready exec:
* get the host that minimizes the completion time.
- * select the task that has the minimum completion time on its best host.
+ * select the exec that has the minimum completion time on its best host.
*/
- double min_finish_time = -1.0;
- sg4::Exec* selected_task = nullptr;
- sg4::Host* selected_host = nullptr;
-
- for (auto task : ready_tasks) {
- XBT_DEBUG("%s is ready", task->get_cname());
- host = get_best_host(task);
- double finish_time = finish_on_at(task, host);
- if (min_finish_time < 0 || finish_time < min_finish_time) {
+ double min_finish_time = std::numeric_limits<double>::max();
+ sg4::Exec* selected_task = nullptr;
+ sg4::Host* selected_host = nullptr;
+
+ for (auto* exec : ready_tasks) {
+ XBT_DEBUG("%s is ready", exec->get_cname());
+ double finish_time;
+ host = get_best_host(exec, &finish_time);
+ if (finish_time < min_finish_time) {
min_finish_time = finish_time;
- selected_task = task;
+ selected_task = exec;
selected_host = host;
}
}
}
/* Cleanup memory */
- for (auto const& host : e.get_all_hosts())
- delete host->get_data<double>();
+ for (auto const* h : e.get_all_hosts())
+ delete h->get_data<double>();
XBT_INFO("Simulation Time: %f", simgrid_get_clock());
