/* Runs a task. */
void SD_task_run(SD_task_t task)
{
xbt_assert(SD_task_get_state(task) == SD_RUNNABLE, "Task '%s' is not runnable! Task state: %d",
SD_task_get_name(task), (int)SD_task_get_state(task));
xbt_assert(task->host_list != nullptr, "Task '%s': workstation_list is nullptr!", SD_task_get_name(task));
XBT_DEBUG("Running task '%s'", SD_task_get_name(task));
/* Copy the elements of the task into the action */
int host_nb = task->host_count;
sg_host_t *hosts = xbt_new(sg_host_t, host_nb);
for (int i = 0; i < host_nb; i++)
hosts[i] = task->host_list[i];
double *flops_amount = xbt_new0(double, host_nb);
double *bytes_amount = xbt_new0(double, host_nb * host_nb);
if(task->flops_amount)
memcpy(flops_amount, task->flops_amount, sizeof(double) * host_nb);
if(task->bytes_amount)
memcpy(bytes_amount, task->bytes_amount, sizeof(double) * host_nb * host_nb);
task->surf_action = surf_host_model->executeParallelTask(host_nb, hosts, flops_amount, bytes_amount, task->rate);
task->surf_action->setData(task);
XBT_DEBUG("surf_action = %p", task->surf_action);
__SD_task_destroy_scheduling_data(task); /* now the scheduling data are not useful anymore */
SD_task_set_state(task, SD_RUNNING);
xbt_dynar_push(sd_global->return_set, &task);
}
/* Changes the state of a task. Updates the sd_global->watch_point_reached flag.
*/
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 (SD_task_get_state(task) == SD_FAILED){
sd_global->completed_tasks->erase(task);
sd_global->initial_tasks->insert(task);
}
break;
case SD_SCHEDULED:
if (SD_task_get_state(task) == SD_RUNNABLE){
sd_global->initial_tasks->insert(task);
sd_global->runnable_tasks->erase(task);
}
break;
case SD_RUNNABLE:
idx = sd_global->initial_tasks->find(task);
if (idx != sd_global->initial_tasks->end()) {
sd_global->runnable_tasks->insert(*idx);
sd_global->initial_tasks->erase(idx);
}
break;
case SD_RUNNING:
sd_global->runnable_tasks->erase(task);
break;
case SD_DONE:
sd_global->completed_tasks->insert(task);
task->start_time = task->surf_action->getStartTime();
task->finish_time = task->surf_action->getFinishTime();
task->surf_action->unref();
task->surf_action = nullptr;
task->remains = 0;
#if HAVE_JEDULE
jedule_log_sd_event(task);
#endif
break;
case SD_FAILED:
sd_global->completed_tasks->insert(task);
task->start_time = task->surf_action->getStartTime();
task->finish_time = surf_get_clock();
task->surf_action->unref();
task->surf_action = nullptr;
break;
default:
xbt_die( "Invalid state");
}
task->state = new_state;
if (task->watch_points & new_state) {
XBT_VERB("Watch point reached with task '%s'!", SD_task_get_name(task));
sd_global->watch_point_reached = true;
SD_task_unwatch(task, new_state); /* remove the watch point */
}
}
int main(int argc, char **argv)
{
unsigned int ctr;
SD_task_t task;
xbt_dynar_t changed_tasks;
SD_init(&argc, argv);
xbt_assert(argc > 1, "Usage: %s platform_file\n\nExample: %s two_clusters.xml", argv[0], argv[0]);
SD_create_environment(argv[1]);
sg_host_t *hosts = sg_host_list();
/* creation of some typed tasks and their dependencies */
/* chain of five tasks, three compute tasks with two data transfers in between */
SD_task_t taskA = SD_task_create_comp_seq("Task A", NULL, 5e9);
SD_task_t taskB = SD_task_create_comm_e2e("Task B", NULL, 1e7);
SD_task_t taskC = SD_task_create_comp_seq("Task C", NULL, 5e9);
SD_task_t taskD = SD_task_create_comm_e2e("Task D", NULL, 1e7);
SD_task_t taskE = SD_task_create_comp_seq("Task E", NULL, 5e9);
SD_task_dependency_add(NULL, NULL, taskA, taskB);
SD_task_dependency_add(NULL, NULL, taskB, taskC);
SD_task_dependency_add(NULL, NULL, taskC, taskD);
SD_task_dependency_add(NULL, NULL, taskD, taskE);
/* Add watchpoints on completion of compute tasks */
SD_task_watch(taskA, SD_DONE);
SD_task_watch(taskC, SD_DONE);
SD_task_watch(taskE, SD_DONE);
/* Auto-schedule the compute tasks on three different workstations */
/* Data transfer tasks taskB and taskD are automagically scheduled */
SD_task_schedulel(taskA, 1, hosts[0]);
SD_task_schedulel(taskC, 1, hosts[1]);
SD_task_schedulel(taskE, 1, hosts[0]);
while (!xbt_dynar_is_empty((changed_tasks = SD_simulate(-1.0)))) {
XBT_INFO("Simulation stopped after %.4f seconds", SD_get_clock());
xbt_dynar_foreach(changed_tasks, ctr, task) {
XBT_INFO("Task '%s' start time: %f, finish time: %f", SD_task_get_name(task), SD_task_get_start_time(task),
SD_task_get_finish_time(task));
}
/* let throttle the communication for taskD if its parent is SD_DONE */
/* the bandwidth is 1.25e8, the data size is 1e7, and we want to throttle the bandwidth by a factor 2.
* The rate is then 1.25e8/(2*1e7)=6.25
* Changing the rate is possible before the task execution starts (in SD_RUNNING state).
*/
if (SD_task_get_state(taskC) == SD_DONE && SD_task_get_state(taskD) < SD_RUNNING)
SD_task_set_rate(taskD, 6.25);
}
/**
* \brief Adds a dependency between two tasks
*
* \a dst will depend on \a src, ie \a dst will not start before \a src is finished.
* Their \ref e_SD_task_state_t "state" must be #SD_NOT_SCHEDULED, #SD_SCHEDULED or #SD_RUNNABLE.
*
* \param name the name of the new dependency (can be \c nullptr)
* \param data the user data you want to associate with this dependency (can be \c nullptr)
* \param src the task which must be executed first
* \param dst the task you want to make depend on \a src
* \see SD_task_dependency_remove()
*/
void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task_t dst)
{
if (src == dst)
THROWF(arg_error, 0, "Cannot add a dependency between task '%s' and itself", SD_task_get_name(src));
e_SD_task_state_t state = SD_task_get_state(src);
if (state == SD_DONE || state == SD_FAILED)
THROWF(arg_error, 0, "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULABLE, SD_SCHEDULED, SD_RUNNABLE, or SD_RUNNING",
SD_task_get_name(src));
state = SD_task_get_state(dst);
if (state == SD_DONE || state == SD_FAILED || state == SD_RUNNING)
THROWF(arg_error, 0, "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULABLE, SD_SCHEDULED, or SD_RUNNABLE",
SD_task_get_name(dst));
if (src->successors->find(dst) != src->successors->end() ||
dst->predecessors->find(src) != dst->predecessors->end() ||
dst->inputs->find(src) != dst->inputs->end() ||
src->outputs->find(dst) != src->outputs->end())
THROWF(arg_error, 0, "A dependency already exists between task '%s' and task '%s'",
SD_task_get_name(src), SD_task_get_name(dst));
XBT_DEBUG("SD_task_dependency_add: src = %s, dst = %s", SD_task_get_name(src), SD_task_get_name(dst));
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 (dst_kind == SD_TASK_COMP_SEQ || dst_kind == SD_TASK_COMP_PAR_AMDAHL){
dst->inputs->insert(src);
} else {
dst->predecessors->insert(src);
}
src->successors->insert(dst);
} else {
if (dst_kind == SD_TASK_COMM_E2E|| dst_kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK){
src->outputs->insert(dst);
} else {
src->successors->insert(dst);
}
dst->predecessors->insert(src);
}
/* 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));
SD_task_set_state(dst, SD_SCHEDULED);
}
}
/**
* \brief Unschedules a task
*
* The task state must be #SD_SCHEDULED, #SD_RUNNABLE, #SD_RUNNING or #SD_FAILED.
* If you call this function, the task state becomes #SD_NOT_SCHEDULED.
* Call SD_task_schedule() to schedule it again.
*
* \param task the task you want to unschedule
* \see SD_task_schedule()
*/
void SD_task_unschedule(SD_task_t task)
{
if (task->state != SD_SCHEDULED && task->state != SD_RUNNABLE && task->state != SD_RUNNING &&
task->state != SD_FAILED)
THROWF(arg_error, 0, "Task %s: the state must be SD_SCHEDULED, SD_RUNNABLE, SD_RUNNING or SD_FAILED",
SD_task_get_name(task));
if ((task->state == SD_SCHEDULED || task->state == SD_RUNNABLE)
/* if the task is scheduled or runnable */
&& ((task->kind == SD_TASK_COMP_PAR_AMDAHL) || (task->kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK))) {
/* Don't free scheduling data for typed tasks */
__SD_task_destroy_scheduling_data(task);
xbt_free(task->host_list);
task->host_list=nullptr;
task->host_count = 0;
}
if (SD_task_get_state(task) == SD_RUNNING)
/* the task should become SD_FAILED */
task->surf_action->cancel();
else {
if (task->predecessors->empty() && task->inputs->empty())
SD_task_set_state(task, SD_SCHEDULABLE);
else
SD_task_set_state(task, SD_NOT_SCHEDULED);
}
task->remains = task->amount;
task->start_time = -1.0;
}
/**
* \brief Remove a dependency between two tasks
*
* \param src a task
* \param dst a task depending on \a src
* \see SD_task_dependency_add()
*/
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() &&
src->outputs->find(dst) == src->outputs->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));
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 (dst_kind == SD_TASK_COMP_SEQ || dst_kind == SD_TASK_COMP_PAR_AMDAHL){
dst->inputs->erase(src);
} else {
dst->predecessors->erase(src);
}
src->successors->erase(dst);
} else {
if (dst_kind == SD_TASK_COMM_E2E|| dst_kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK){
src->outputs->erase(dst);
} else {
src->successors->erase(dst);
}
dst->predecessors->erase(src);
}
/* if the task was scheduled and dependencies are satisfied, we can make it runnable */
if (dst->predecessors->empty() && dst->inputs->empty() && SD_task_get_state(dst) == SD_SCHEDULED)
SD_task_set_state(dst, SD_RUNNABLE);
}
/* Build the set of the compute successors of a task that are ready (i.e., with all parents already scheduled). Both
* data and control dependencies are checked. As more than one transfer may exist between two compute tasks, it is
* mandatory to check whether the successor is not already in the set.
*/
xbt_dynar_t SD_task_get_ready_children(SD_task_t t){
unsigned int i;
xbt_dynar_t children=NULL, ready_children;
xbt_dynar_t output_transfers = SD_task_get_children(t);
SD_task_t output, child;
ready_children = xbt_dynar_new(sizeof(SD_task_t), NULL);
xbt_dynar_foreach(output_transfers, i, output){
if (SD_task_get_kind(output) == SD_TASK_COMM_E2E) {
/* Data dependency case: a compute task is followed by a data transfer. Its child (in a scheduling sense) is
* then the grand child
*/
children = SD_task_get_children(output);
xbt_dynar_get_cpy(children, 0, &child);
/* check if this child is already in the set */
if (xbt_dynar_member(ready_children, &child)){
XBT_DEBUG("%s already seen, ignore", SD_task_get_name(child));
xbt_dynar_free_container(&children); /* avoid memory leaks */
continue;
}
if (SD_task_get_kind(child) == SD_TASK_COMP_SEQ && (SD_task_get_state(child) == SD_NOT_SCHEDULED ||
SD_task_get_state(child) == SD_SCHEDULABLE) && SD_task_is_ready(child)){
xbt_dynar_push(ready_children, &child);
}
xbt_dynar_free_container(&children); /* avoid memory leaks */
} else {
/* Control dependency case: a compute task successor is another compute task. */
/* check if this child is already in the set */
if (xbt_dynar_member(ready_children, &output)){
XBT_DEBUG("%s already seen, ignore", SD_task_get_name(output));
continue;
}
if (SD_task_get_kind(output) == SD_TASK_COMP_SEQ && (SD_task_get_state(output) == SD_NOT_SCHEDULED ||
SD_task_get_state(output) == SD_SCHEDULABLE)&& SD_task_is_ready(output)){
xbt_dynar_push(ready_children, &output);
}
}
}
xbt_dynar_free_container(&output_transfers); /* avoid memory leaks */
return ready_children;
}
static inline void SD_task_do_schedule(SD_task_t task)
{
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->predecessors->empty() && task->inputs->empty())
SD_task_set_state(task, SD_RUNNABLE);
else
SD_task_set_state(task, SD_SCHEDULED);
}
int main(int argc, char **argv)
{
unsigned int ctr;
SD_task_t task;
xbt_dynar_t changed_tasks;
SD_init(&argc, argv);
SD_create_environment(argv[1]);
const sg_host_t *hosts = sg_host_list();
SD_task_t t1 = SD_task_create_comp_seq("t1", NULL, 25000000);
SD_task_t c1 = SD_task_create_comm_e2e("c1", NULL, 125000000);
SD_task_t t2 = SD_task_create_comp_seq("t2", NULL, 25000000);
SD_task_t c2 = SD_task_create_comm_e2e("c2", NULL, 62500000);
SD_task_t t3 = SD_task_create_comp_seq("t3", NULL, 25000000);
SD_task_t c3 = SD_task_create_comm_e2e("c3", NULL, 31250000);
SD_task_t t4 = SD_task_create_comp_seq("t4", NULL, 25000000);
/* Add dependencies: t1->c1->t2->c2->t3 */
SD_task_dependency_add(NULL, NULL, t1, c1);
SD_task_dependency_add(NULL, NULL, c1, t2);
SD_task_dependency_add(NULL, NULL, t2, c2);
SD_task_dependency_add(NULL, NULL, c2, t3);
SD_task_dependency_add(NULL, NULL, t3, c3);
SD_task_dependency_add(NULL, NULL, c3, t4);
/* Schedule tasks t1 and w3 on first host, t2 on second host */
/* Transfers are auto-scheduled */
SD_task_schedulel(t1, 1, hosts[0]);
SD_task_schedulel(t2, 1, hosts[1]);
SD_task_schedulel(t3, 1, hosts[0]);
SD_task_schedulel(t4, 1, hosts[1]);
/* Add some watchpoint upon task completion */
SD_task_watch(t1, SD_DONE);
SD_task_watch(c1, SD_DONE);
SD_task_watch(t2, SD_DONE);
SD_task_watch(c2, SD_DONE);
SD_task_watch(t3, SD_DONE);
SD_task_watch(c3, SD_DONE);
SD_task_watch(t4, SD_DONE);
while (!xbt_dynar_is_empty((changed_tasks = SD_simulate(-1.0)))) {
XBT_INFO("link1: bw=%.0f, lat=%f", SD_route_get_bandwidth(hosts[0], hosts[1]),
SD_route_get_latency(hosts[0], hosts[1]));
XBT_INFO("Jupiter: speed=%.0f", sg_host_speed(hosts[0])* sg_host_get_available_speed(hosts[0]));
XBT_INFO("Tremblay: speed=%.0f", sg_host_speed(hosts[1])* sg_host_get_available_speed(hosts[1]));
xbt_dynar_foreach(changed_tasks, ctr, task) {
XBT_INFO("Task '%s' start time: %f, finish time: %f", SD_task_get_name(task),
SD_task_get_start_time(task), SD_task_get_finish_time(task));
if (SD_task_get_state(task)==SD_DONE)
SD_task_destroy(task);
}
}
/* When some independent tasks are scheduled on the same resource, the SimGrid kernel start them in parallel as soon
* as possible even though the scheduler assumed a sequential execution. This function addresses this issue by
* enforcing that sequential execution wanted by the scheduler. A resource dependency is added to that extent.
*/
void handle_resource_dependency(sg_host_t host, SD_task_t task){
/* Get the last task executed on this host */
SD_task_t source = sg_host_get_last_scheduled_task(host);
/* If such a task exists, is still in the system (scheduled or running) and is not already a predecessor of the
* current task, create a resource dependency
*/
if (source && (SD_task_get_state(source)!= SD_DONE) && !SD_task_dependency_exists(source, task))
SD_task_dependency_add("resource", NULL, source, task);
/* update the information on what is the last task executed on this host */
sg_host_set_last_scheduled_task(host, task);
}
/* Determine if a task is ready. The condition to meet is that all its compute predecessors have to be in one of the
* following state:
* - SD_RUNNABLE
* - SD_RUNNING
* - SD_DONE
*/
int SD_task_is_ready(SD_task_t task){
unsigned int i;
int is_ready = 1;
xbt_dynar_t parents, grand_parents;
SD_task_t parent, grand_parent;
parents = SD_task_get_parents(task);
if (xbt_dynar_length(parents)) {
xbt_dynar_foreach(parents, i, parent){
if (SD_task_get_kind(parent) == SD_TASK_COMM_E2E) {
/* Data dependency case: a compute task is preceded by a data transfer. Its parent (in a scheduling sense) is
* then the grand parent
*/
grand_parents = SD_task_get_parents(parent);
xbt_dynar_get_cpy(grand_parents, 0, &grand_parent);
if (SD_task_get_state(grand_parent) < SD_SCHEDULED) {
is_ready =0;
xbt_dynar_free_container(&grand_parents); /* avoid memory leaks */
break;
} else {
xbt_dynar_free_container(&grand_parents); /* avoid memory leaks */
}
} else {
/* Control dependency case: a compute task predecessor is another compute task. */
if (SD_task_get_state(parent) < SD_SCHEDULED) {
is_ready =0;
break;
}
}
}
}
xbt_dynar_free_container(&parents); /* avoid memory leaks */
return is_ready;
}
static xbt_dynar_t get_ready_tasks(xbt_dynar_t dax)
{
unsigned int i;
xbt_dynar_t ready_tasks;
SD_task_t task;
ready_tasks = xbt_dynar_new(sizeof(SD_task_t), NULL);
xbt_dynar_foreach(dax, i, task) {
if (SD_task_get_kind(task) == SD_TASK_COMP_SEQ && SD_task_get_state(task) == SD_SCHEDULABLE) {
xbt_dynar_push(ready_tasks, &task);
}
}
XBT_DEBUG("There are %lu ready tasks", xbt_dynar_length(ready_tasks));
return ready_tasks;
}
int main(int argc, char **argv)
{
unsigned int ctr;
const char *platform_file;
const SD_workstation_t *workstations;
SD_task_t task, taskA, taskB, taskC, taskD, taskE;
xbt_dynar_t changed_tasks;
/* initialization of SD */
SD_init(&argc, argv);
/* xbt_log_control_set("sd.thres=debug"); */
if (argc < 2) {
XBT_INFO("Usage: %s platform_file", argv[0]);
XBT_INFO("example: %s sd_platform.xml", argv[0]);
exit(1);
}
/* creation of the environment */
platform_file = argv[1];
SD_create_environment(platform_file);
workstations = SD_workstation_get_list();
/* creation of some typed tasks and their dependencies */
/* chain of five tasks, three compute tasks with two data transfers */
/* in between */
taskA = SD_task_create_comp_seq("Task A", NULL, 5e9);
taskB = SD_task_create_comm_e2e("Task B", NULL, 1e7);
taskC = SD_task_create_comp_seq("Task C", NULL, 5e9);
taskD = SD_task_create_comm_e2e("Task D", NULL, 1e7);
taskE = SD_task_create_comp_seq("Task E", NULL, 5e9);
SD_task_dependency_add(NULL, NULL, taskA, taskB);
SD_task_dependency_add(NULL, NULL, taskB, taskC);
SD_task_dependency_add(NULL, NULL, taskC, taskD);
SD_task_dependency_add(NULL, NULL, taskD, taskE);
/* Add watchpoints on completion of compute tasks */
SD_task_watch(taskA, SD_DONE);
SD_task_watch(taskC, SD_DONE);
SD_task_watch(taskE, SD_DONE);
/* Auto-schedule the compute tasks on three different workstations */
/* Data transfer tasks taskB and taskD are automagically scheduled */
SD_task_schedulel(taskA, 1, workstations[0]);
SD_task_schedulel(taskC, 1, workstations[1]);
SD_task_schedulel(taskE, 1, workstations[0]);
while (!xbt_dynar_is_empty((changed_tasks = SD_simulate(-1.0)))) {
XBT_INFO("Simulation stopped after %.4f seconds", SD_get_clock());
xbt_dynar_foreach(changed_tasks, ctr, task) {
XBT_INFO("Task '%s' start time: %f, finish time: %f",
SD_task_get_name(task),
SD_task_get_start_time(task),
SD_task_get_finish_time(task));
}
/* let throttle the communication for taskD if its parent is SD_DONE */
/* the bandwidth is 1.25e8, the data size is 1e7, and we want to throttle
* the bandwidth by a factor 2. the rate is then 1.25e8/(2*1e7)=6.25
* Changing the rate is possible before the task execution starts (in SD_RUNNING
* state).
*/
if (SD_task_get_state(taskC) == SD_DONE && SD_task_get_state(taskD) < SD_RUNNING)
SD_task_set_rate(taskD, 6.25);
xbt_dynar_free_container(&changed_tasks);
}
