* \see SD_task_destroy()
*/
SD_task_t SD_task_create(const char *name, void *data, double amount) {
+
+ SD_task_t task;
SD_CHECK_INIT_DONE();
- SD_task_t task = xbt_new0(s_SD_task_t, 1);
+ task = xbt_new(s_SD_task_t, 1);
/* general information */
task->data = data; /* user data */
else
task->name = NULL;
+ task->state_hookup.prev = NULL;
+ task->state_hookup.next = NULL;
task->state_set = sd_global->not_scheduled_task_set;
- xbt_swag_insert(task,task->state_set);
+ task->state = SD_NOT_SCHEDULED;
+ xbt_swag_insert(task, task->state_set);
task->amount = amount;
task->remains = amount;
task->communication_amount = NULL;
task->rate = 0;
+ sd_global->task_number++;
+
return task;
}
e_SD_task_state_t SD_task_get_state(SD_task_t task) {
SD_CHECK_INIT_DONE();
xbt_assert0(task != NULL, "Invalid parameter");
-
- if (task->state_set == sd_global->scheduled_task_set)
- return SD_SCHEDULED;
- if (task->state_set == sd_global->done_task_set)
- return SD_DONE;
- if (task->state_set == sd_global->running_task_set)
- return SD_RUNNING;
- if (task->state_set == sd_global->ready_task_set)
- return SD_READY;
- if (task->state_set == sd_global->in_fifo_task_set)
- return SD_IN_FIFO;
- if (task->state_set == sd_global->not_scheduled_task_set)
- return SD_NOT_SCHEDULED;
- return SD_FAILED;
+ return task->state;
}
/* Changes the state of a task. Updates the swags and the flag sd_global->watch_point_reached.
xbt_assert0(0, "Invalid state");
}
xbt_swag_insert(task, task->state_set);
+ task->state = new_state;
if (task->watch_points & new_state) {
INFO1("Watch point reached with task '%s'!", SD_task_get_name(task));
/* temporary function for debbuging */
static void __SD_print_dependencies(SD_task_t task) {
- INFO1("The following tasks must be executed before %s:", SD_task_get_name(task));
- xbt_dynar_t dynar = task->tasks_before;
- int length = xbt_dynar_length(dynar);
+ xbt_dynar_t dynar;
+ int length;
int i;
SD_dependency_t dependency;
+
+ INFO1("The following tasks must be executed before %s:", SD_task_get_name(task));
+ dynar = task->tasks_before;
+ length = xbt_dynar_length(dynar);
+
+
for (i = 0; i < length; i++) {
xbt_dynar_get_cpy(dynar, i, &dependency);
INFO1(" %s", SD_task_get_name(dependency->src));
* \see SD_task_dependency_remove()
*/
void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task_t dst) {
- SD_CHECK_INIT_DONE();
- xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
-
- xbt_dynar_t dynar = src->tasks_after;
- int length = xbt_dynar_length(dynar);
+ xbt_dynar_t dynar;
+ int length;
int found = 0;
int i;
SD_dependency_t dependency;
+ SD_CHECK_INIT_DONE();
+ xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
+
+ dynar = src->tasks_after;
+ length = xbt_dynar_length(dynar);
+
+
+
if (src == dst)
THROW1(arg_error, 0, "Cannot add a dependency between task '%s' and itself",
SD_task_get_name(src));
THROW2(arg_error, 0, "A dependency already exists between task '%s' and task '%s'",
SD_task_get_name(src), SD_task_get_name(dst));
- dependency = xbt_new0(s_SD_dependency_t, 1);
+ dependency = xbt_new(s_SD_dependency_t, 1);
if (name != NULL)
dependency->name = xbt_strdup(name);
* \see SD_task_dependency_add()
*/
void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) {
- SD_CHECK_INIT_DONE();
- xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
- /* remove the dependency from src->tasks_after */
- xbt_dynar_t dynar = src->tasks_after;
- int length = xbt_dynar_length(dynar);
+ xbt_dynar_t dynar;
+ int length;
int found = 0;
int i;
SD_dependency_t dependency;
+
+ SD_CHECK_INIT_DONE();
+ xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
+
+ /* remove the dependency from src->tasks_after */
+ dynar = src->tasks_after;
+ length = xbt_dynar_length(dynar);
+
for (i = 0; i < length && !found; i++) {
xbt_dynar_get_cpy(dynar, i, &dependency);
if (dependency->dst == dst) {
* \see SD_task_dependency_add()
*/
void *SD_task_dependency_get_data(SD_task_t src, SD_task_t dst) {
- SD_CHECK_INIT_DONE();
- xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
- xbt_dynar_t dynar = src->tasks_after;
- int length = xbt_dynar_length(dynar);
+ xbt_dynar_t dynar;
+ int length;
int found = 0;
int i;
SD_dependency_t dependency;
+
+
+ SD_CHECK_INIT_DONE();
+ xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
+
+ dynar = src->tasks_after;
+ length = xbt_dynar_length(dynar);
+
for (i = 0; i < length && !found; i++) {
xbt_dynar_get_cpy(dynar, i, &dependency);
found = (dependency->dst == dst);
static void __SD_print_watch_points(SD_task_t task) {
static const int state_masks[] = {SD_SCHEDULED, SD_RUNNING, SD_READY, SD_DONE, SD_FAILED};
static const char* state_names[] = {"scheduled", "running", "ready", "done", "failed"};
+ int i;
INFO2("Task '%s' watch points (%x): ", SD_task_get_name(task), task->watch_points);
- int i;
+
for (i = 0; i < 5; i++) {
if (task->watch_points & state_masks[i])
INFO1("%s ", state_names[i]);
const double *computation_amount,
const double *communication_amount,
double rate) {
+ double time, max_time = 0.0;
+ int i, j;
SD_CHECK_INIT_DONE();
xbt_assert0(task != NULL && workstation_nb > 0 && workstation_list != NULL &&
computation_amount != NULL && communication_amount != NULL,
"Invalid parameter");
/* the task execution time is the maximum execution time of the parallel tasks */
- double time, max_time = 0.0;
- int i, j;
+
for (i = 0; i < workstation_nb; i++) {
time = SD_workstation_get_computation_time(workstation_list[i], computation_amount[i]);
void SD_task_schedule(SD_task_t task, int workstation_nb,
const SD_workstation_t *workstation_list, const double *computation_amount,
const double *communication_amount, double rate) {
+
+ int communication_nb;
+
SD_CHECK_INIT_DONE();
xbt_assert0(task != NULL, "Invalid parameter");
xbt_assert0(workstation_nb > 0, "workstation_nb must be positive");
task->workstation_nb = workstation_nb;
task->rate = rate;
- task->computation_amount = xbt_new0(double, workstation_nb);
+ task->computation_amount = xbt_new(double, workstation_nb);
memcpy(task->computation_amount, computation_amount, sizeof(double) * workstation_nb);
- int communication_nb = workstation_nb * workstation_nb;
- task->communication_amount = xbt_new0(double, communication_nb);
+ communication_nb = workstation_nb * workstation_nb;
+ task->communication_amount = xbt_new(double, communication_nb);
memcpy(task->communication_amount, communication_amount, sizeof(double) * communication_nb);
- task->workstation_list = xbt_new0(SD_workstation_t, workstation_nb);
+ task->workstation_list = xbt_new(SD_workstation_t, workstation_nb);
memcpy(task->workstation_list, workstation_list, sizeof(SD_workstation_t) * workstation_nb);
/* update the task state */
* the task gets out of its fifos.
*/
void __SD_task_really_run(SD_task_t task) {
+
+ int i;
+ void **surf_workstations;
+
SD_CHECK_INIT_DONE();
xbt_assert0(task != NULL, "Invalid parameter");
xbt_assert2(__SD_task_is_ready_or_in_fifo(task), "Task '%s' is not ready or in a fifo! Task state: %d",
SD_task_get_name(task), SD_task_get_state(task));
xbt_assert1(task->workstation_list != NULL, "Task '%s': workstation_list is NULL!", SD_task_get_name(task));
- int i;
- void **surf_workstations;
+
DEBUG1("Really running task '%s'", SD_task_get_name(task));
/* start the task */
/* we have to create a Surf workstation array instead of the SimDag workstation array */
- surf_workstations = xbt_new0(void*, task->workstation_nb);
+ surf_workstations = xbt_new(void*, task->workstation_nb);
for (i = 0; i < task->workstation_nb; i++) {
surf_workstations[i] = task->workstation_list[i]->surf_workstation;
* Returns whether the task has started.
*/
int __SD_task_try_to_run(SD_task_t task) {
+
+ int can_start = 1;
+ int i;
+ SD_workstation_t workstation;
+
SD_CHECK_INIT_DONE();
xbt_assert0(task != NULL, "Invalid parameter");
xbt_assert2(__SD_task_is_ready(task), "Task '%s' is not ready! Task state: %d",
SD_task_get_name(task), SD_task_get_state(task));
- int can_start = 1;
- int i;
- SD_workstation_t workstation;
for (i = 0; i < task->workstation_nb; i++) {
can_start = !__SD_workstation_is_busy(task->workstation_list[i]);
* which were waiting in fifos for the end of `task'
*/
void __SD_task_just_done(SD_task_t task) {
- SD_CHECK_INIT_DONE();
- xbt_assert0(task != NULL, "Invalid parameter");
- xbt_assert1(__SD_task_is_running(task), "The task must be running! Task state: %d", SD_task_get_state(task));
- xbt_assert1(task->workstation_list != NULL, "Task '%s': workstation_list is NULL!", SD_task_get_name(task));
-
- int i, j;
+ int i, j;
SD_workstation_t workstation;
SD_task_t candidate;
int candidate_nb = 0;
int candidate_capacity = 8;
- SD_task_t *candidates = xbt_new0(SD_task_t, 8);
+ SD_task_t *candidates;
int can_start = 1;
+ SD_CHECK_INIT_DONE();
+ xbt_assert0(task != NULL, "Invalid parameter");
+ xbt_assert1(__SD_task_is_running(task), "The task must be running! Task state: %d", SD_task_get_state(task));
+ xbt_assert1(task->workstation_list != NULL, "Task '%s': workstation_list is NULL!", SD_task_get_name(task));
+
+
+ candidates = xbt_new(SD_task_t, 8);
+
__SD_task_set_state(task, SD_DONE);
surf_workstation_resource->common_public->action_free(task->surf_action);
task->surf_action = NULL;
xbt_dynar_free(&task->tasks_after);
xbt_free(task);
+ sd_global->task_number--;
+
DEBUG0("Task destroyed.");
}
