> [Tremblay:Receiver:(3) 2.957786] [jmsg/INFO] --- bw 1.1627602630025032E8 ----
> [Tremblay:Receiver:(3) 3.817809] [jmsg/INFO] goodbye!
-$ rm -rf simulation.trace
+!$ rm -rf simulation.trace
xbt_dynar_foreach(parents, i, parent) {
/* normal case */
if (SD_task_get_kind(parent) == SD_TASK_COMM_E2E) {
- xbt_dynar_t grand_parents = SD_task_get_parents(parent);
- SD_task_t grand_parent;
-
- xbt_assert(xbt_dynar_length(grand_parents) <2, "Error: transfer %s has 2 parents", SD_task_get_name(parent));
-
- xbt_dynar_get_cpy(grand_parents, 0, &grand_parent);
-
- sg_host_t * grand_parent_host_list = SD_task_get_workstation_list(grand_parent);
+ sg_host_t * parent_host= SD_task_get_workstation_list(parent);
/* Estimate the redistribution time from this parent */
if (SD_task_get_amount(parent) <= 1e-6){
redist_time= 0;
} else {
- redist_time = SD_route_get_latency(grand_parent_host_list[0], host) +
- SD_task_get_amount(parent) / SD_route_get_bandwidth(grand_parent_host_list[0], host);
+ redist_time = SD_route_get_latency(parent_host[0], host) +
+ SD_task_get_amount(parent) / SD_route_get_bandwidth(parent_host[0], host);
}
- data_available = SD_task_get_finish_time(grand_parent) + redist_time;
-
- xbt_dynar_free_container(&grand_parents);
+ data_available = SD_task_get_start_time(parent) + redist_time;
}
/* no transfer, control dependency */
static sg_host_t SD_task_get_best_host(SD_task_t task)
{
- const sg_host_t *hosts = sg_host_list();
+ sg_host_t *hosts = sg_host_list();
int nhosts = sg_host_count();
sg_host_t best_host = hosts[0];
double min_EFT = finish_on_at(task, hosts[0]);
best_host = hosts[i];
}
}
+ xbt_free(hosts);
return best_host;
}
/* Allocating the host attribute */
int total_nhosts = sg_host_count();
- const sg_host_t *hosts = sg_host_list();
+ sg_host_t *hosts = sg_host_list();
for (cursor = 0; cursor < total_nhosts; cursor++)
sg_host_allocate_attribute(hosts[cursor]);
for (cursor = 0; cursor < total_nhosts; cursor++)
sg_host_free_attribute(hosts[cursor]);
+ xbt_free(hosts);
/* exit */
SD_exit();
return 0;
/* remove the dependencies after this task */
for (std::set<SD_task_t>::iterator it=task->successors->begin(); it!=task->successors->end(); ++it){
dst=*it;
- dst->unsatisfied_dependencies--;
- if (dst->is_not_ready > 0)
- dst->is_not_ready--;
- XBT_DEBUG("Released a dependency on %s: %d remain(s). Became schedulable if %d=0",
- SD_task_get_name(dst), dst->unsatisfied_dependencies, dst->is_not_ready);
- if (dst->unsatisfied_dependencies == 0) {
+ dst->predecessors->erase(task);
+ dst->inputs->erase(task);
+ XBT_DEBUG("Released a dependency on %s: %zu remain(s). Became schedulable if %zu=0",
+ SD_task_get_name(dst), dst->predecessors->size()+dst->inputs->size(), dst->predecessors->size());
+ if (dst->predecessors->empty() && dst->inputs->empty()) {
if (SD_task_get_state(dst) == SD_SCHEDULED)
SD_task_set_state(dst, SD_RUNNABLE);
else
SD_task_set_state(dst, SD_SCHEDULABLE);
}
- if (SD_task_get_state(dst) == SD_NOT_SCHEDULED && dst->is_not_ready == 0) {
+ if (SD_task_get_state(dst) == SD_NOT_SCHEDULED && dst->predecessors->empty()){
SD_task_set_state(dst, SD_SCHEDULABLE);
}
if (SD_task_get_state(dst) == SD_RUNNABLE && !sd_global->watch_point_reached) {
xbt_dynar_push(sd_global->return_set, &dst);
}
}
+ task->successors->clear();
for (std::set<SD_task_t>::iterator it=task->outputs->begin(); it!=task->outputs->end(); ++it){
dst=*it;
- dst->unsatisfied_dependencies = 0;
- dst->is_not_ready = 0;
+ dst->start_time = task->finish_time;
+ dst->predecessors->erase(task);
if (SD_task_get_state(dst) == SD_SCHEDULED)
SD_task_set_state(dst, SD_RUNNABLE);
else
SD_task_set_state(dst, SD_SCHEDULABLE);
SD_task_t comm_dst = *(dst->successors->begin());
- if (SD_task_get_state(comm_dst) == SD_NOT_SCHEDULED && comm_dst->is_not_ready > 0) {
- comm_dst->is_not_ready--;
-
- XBT_DEBUG("%s is a transfer, %s may be ready now if %d=0",
- SD_task_get_name(dst), SD_task_get_name(comm_dst), comm_dst->is_not_ready);
-
- if (comm_dst->is_not_ready == 0) {
- SD_task_set_state(comm_dst, SD_SCHEDULABLE);
- }
+ if (SD_task_get_state(comm_dst) == SD_NOT_SCHEDULED && comm_dst->predecessors->empty()){
+ XBT_DEBUG("%s is a transfer, %s may be ready now if %zu=0",
+ SD_task_get_name(dst), SD_task_get_name(comm_dst), comm_dst->predecessors->size());
+ SD_task_set_state(comm_dst, SD_SCHEDULABLE);
}
if (SD_task_get_state(dst) == SD_RUNNABLE && !sd_global->watch_point_reached) {
XBT_VERB("Executing task '%s'", SD_task_get_name(dst));
xbt_dynar_push(sd_global->return_set, &dst);
}
}
+ task->outputs->clear();
}
/* let's see which tasks have just failed */
task->watch_points = 0;
/* dependencies */
- task->unsatisfied_dependencies = 0;
- task->is_not_ready = 0;
-
task->inputs->clear();
task->outputs->clear();
task->predecessors->clear();
void SD_task_set_rate(SD_task_t task, double rate)
{
xbt_assert(task->kind == SD_TASK_COMM_E2E, "The rate can be modified for end-to-end communications only.");
- if(task->start_time<0) {
+ if(task->state < SD_RUNNING) {
task->rate = rate;
} else {
XBT_WARN("Task %p has started. Changing rate is ineffective.", task);
void SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
{
std::set<SD_task_t>::iterator idx;
+ XBT_DEBUG("Set state of '%s' to %d", task->name, new_state);
switch (new_state) {
case SD_NOT_SCHEDULED:
case SD_SCHEDULABLE:
}
}
- if (task->category)
- XBT_INFO(" - tracing category: %s", task->category);
-
XBT_INFO(" - amount: %.0f", SD_task_get_amount(task));
if (task->kind == SD_TASK_COMP_PAR_AMDAHL)
XBT_INFO(" - alpha: %.2f", task->alpha);
- XBT_INFO(" - Dependencies to satisfy: %d", task->unsatisfied_dependencies);
+ XBT_INFO(" - Dependencies to satisfy: %zu", task->inputs->size()+ task->predecessors->size());
if ((task->inputs->size()+ task->predecessors->size()) > 0) {
XBT_INFO(" - pre-dependencies:");
for (std::set<SD_task_t>::iterator it=task->predecessors->begin(); it!=task->predecessors->end(); ++it)
dst->predecessors->insert(src);
}
- dst->unsatisfied_dependencies++;
- dst->is_not_ready++;
-
/* if the task was runnable, the task goes back to SD_SCHEDULED because of the new dependency*/
if (SD_task_get_state(dst) == SD_RUNNABLE) {
XBT_DEBUG("SD_task_dependency_add: %s was runnable and becomes scheduled!", SD_task_get_name(dst));
*/
void SD_task_dependency_remove(SD_task_t src, SD_task_t dst)
{
-
XBT_DEBUG("SD_task_dependency_remove: src = %s, dst = %s", SD_task_get_name(src), SD_task_get_name(dst));
if (src->successors->find(dst) == src->successors->end() &&
THROWF(arg_error, 0, "No dependency found between task '%s' and '%s': task '%s' is not a successor of task '%s'",
SD_task_get_name(src), SD_task_get_name(dst), SD_task_get_name(dst), SD_task_get_name(src));
- if (dst->predecessors->find(src) != dst->predecessors->end() ||
- dst->inputs->find(src) != dst->inputs->end()){
- dst->unsatisfied_dependencies--;
- dst->is_not_ready--;
- }
-
e_SD_task_kind_t src_kind = SD_task_get_kind(src);
e_SD_task_kind_t dst_kind = SD_task_get_kind(dst);
if (src_kind == SD_TASK_COMM_E2E || src_kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK){
}
/* if the task was scheduled and dependencies are satisfied, we can make it runnable */
- if (dst->unsatisfied_dependencies == 0) {
- if (SD_task_get_state(dst) == SD_SCHEDULED)
- SD_task_set_state(dst, SD_RUNNABLE);
- else
- SD_task_set_state(dst, SD_SCHEDULABLE);
- }
-
- if (dst->is_not_ready == 0)
- SD_task_set_state(dst, SD_SCHEDULABLE);
+ if (dst->predecessors->empty() && dst->inputs->empty() && SD_task_get_state(dst) == SD_SCHEDULED)
+ SD_task_set_state(dst, SD_RUNNABLE);
}
/**
if (SD_task_get_state(task) > SD_SCHEDULABLE)
THROWF(arg_error, 0, "Task '%s' has already been scheduled", SD_task_get_name(task));
- if (task->unsatisfied_dependencies == 0)
+ if (task->predecessors->empty() && task->inputs->empty())
SD_task_set_state(task, SD_RUNNABLE);
else
SD_task_set_state(task, SD_SCHEDULED);
/* the task should become SD_FAILED */
task->surf_action->cancel();
else {
- if (task->unsatisfied_dependencies == 0)
+ if (task->predecessors->empty() && task->inputs->empty())
SD_task_set_state(task, SD_SCHEDULABLE);
else
SD_task_set_state(task, SD_NOT_SCHEDULED);
XBT_DEBUG("surf_action = %p", task->surf_action);
- if (task->category)
- TRACE_surf_action(task->surf_action, task->category);
-
__SD_task_destroy_scheduling_data(task); /* now the scheduling data are not useful anymore */
SD_task_set_state(task, SD_RUNNING);
}
int marked; /* used to check if the task DAG has some cycle*/
/* dependencies */
- int unsatisfied_dependencies;
- unsigned int is_not_ready;
-
std::set<SD_task_t> *inputs;
std::set<SD_task_t> *outputs;
std::set<SD_task_t> *predecessors;
double *flops_amount;
double *bytes_amount;
double rate;
-
- long long int counter; /* task unique identifier for instrumentation */
- char *category; /* sd task category for instrumentation */
} s_SD_task_t;
/* SimDag private functions */