git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@2819
48e7efb5-ca39-0410-a469-
dd3cf9ba447f
m_process_t process = MSG_process_self();
m_task_t t = NULL;
m_host_t h = NULL;
m_process_t process = MSG_process_self();
m_task_t t = NULL;
m_host_t h = NULL;
+ m_task_t task_to_wait_for;
simdata_task_t t_simdata = NULL;
simdata_host_t h_simdata = NULL;
int first_time = 1;
simdata_task_t t_simdata = NULL;
simdata_host_t h_simdata = NULL;
int first_time = 1;
while(MSG_process_is_suspended(t_simdata->sender)) {
DEBUG1("Oooups, the sender (%s) has been suspended in the meantime. Let's wait for him",
t_simdata->sender->name);
while(MSG_process_is_suspended(t_simdata->sender)) {
DEBUG1("Oooups, the sender (%s) has been suspended in the meantime. Let's wait for him",
t_simdata->sender->name);
- m_task_t task_to_wait_for = t_simdata->sender->simdata->waiting_task;
+ /*m_task_t task_to_wait_for = t_simdata->sender->simdata->waiting_task;*/
+ task_to_wait_for = t_simdata->sender->simdata->waiting_task;
if(__MSG_process_isBlocked(t_simdata->sender)) {
DEBUG0("He's blocked. Let's wait for him to go in the suspended state");
__MSG_process_unblock(t_simdata->sender);
if(__MSG_process_isBlocked(t_simdata->sender)) {
DEBUG0("He's blocked. Let's wait for him to go in the suspended state");
__MSG_process_unblock(t_simdata->sender);
*/
int MSG_host_is_avail (m_host_t h)
{
*/
int MSG_host_is_avail (m_host_t h)
{
+ e_surf_cpu_state_t cpustate;
xbt_assert0((h!= NULL), "Invalid parameters");
xbt_assert0((h!= NULL), "Invalid parameters");
- e_surf_cpu_state_t cpustate =
surf_workstation_resource->extension_public->get_state(h->simdata->host);
xbt_assert0((cpustate == SURF_CPU_ON || cpustate == SURF_CPU_OFF),
surf_workstation_resource->extension_public->get_state(h->simdata->host);
xbt_assert0((cpustate == SURF_CPU_ON || cpustate == SURF_CPU_OFF),
* \see SD_create_environment(), SD_exit()
*/
void SD_init(int *argc, char **argv) {
* \see SD_create_environment(), SD_exit()
*/
void SD_init(int *argc, char **argv) {
if (SD_INITIALISED()) {
xbt_assert0(0, "SD_init() already called");
}
if (SD_INITIALISED()) {
xbt_assert0(0, "SD_init() already called");
}
sd_global->recyclable_route = NULL;
sd_global->watch_point_reached = 0;
sd_global->recyclable_route = NULL;
sd_global->watch_point_reached = 0;
sd_global->not_scheduled_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup));
sd_global->scheduled_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup));
sd_global->ready_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup));
sd_global->not_scheduled_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup));
sd_global->scheduled_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup));
sd_global->ready_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup));
/* Creates a link and registers it in SD.
*/
SD_link_t __SD_link_create(void *surf_link, void *data) {
/* Creates a link and registers it in SD.
*/
SD_link_t __SD_link_create(void *surf_link, void *data) {
+
+ SD_link_t link;
+ const char *name;
+
SD_CHECK_INIT_DONE();
xbt_assert0(surf_link != NULL, "surf_link is NULL !");
SD_CHECK_INIT_DONE();
xbt_assert0(surf_link != NULL, "surf_link is NULL !");
- SD_link_t link = xbt_new(s_SD_link_t, 1);
+ link = xbt_new(s_SD_link_t, 1);
link->surf_link = surf_link;
link->data = data; /* user data */
link->surf_link = surf_link;
link->data = data; /* user data */
- const char *name = SD_link_get_name(link);
+ name = SD_link_get_name(link);
xbt_dict_set(sd_global->links, name, link, __SD_link_destroy); /* add the link to the dictionary */
sd_global->link_count++;
xbt_dict_set(sd_global->links, name, link, __SD_link_destroy); /* add the link to the dictionary */
sd_global->link_count++;
* \see SD_link_get_number()
*/
const SD_link_t* SD_link_get_list(void) {
* \see SD_link_get_number()
*/
const SD_link_t* SD_link_get_list(void) {
- SD_CHECK_INIT_DONE();
- xbt_assert0(SD_link_get_number() > 0, "There is no link!");
xbt_dict_cursor_t cursor;
char *key;
void *data;
int i;
xbt_dict_cursor_t cursor;
char *key;
void *data;
int i;
+
+ SD_CHECK_INIT_DONE();
+ xbt_assert0(SD_link_get_number() > 0, "There is no link!");
if (sd_global->link_list == NULL) { /* this is the first time the function is called */
sd_global->link_list = xbt_new(SD_link_t, sd_global->link_count);
if (sd_global->link_list == NULL) { /* this is the first time the function is called */
sd_global->link_list = xbt_new(SD_link_t, sd_global->link_count);
* \see SD_task_destroy()
*/
SD_task_t SD_task_create(const char *name, void *data, double amount) {
* \see SD_task_destroy()
*/
SD_task_t SD_task_create(const char *name, void *data, double amount) {
- SD_task_t task = xbt_new(s_SD_task_t, 1);
+ task = xbt_new(s_SD_task_t, 1);
/* general information */
task->data = data; /* user data */
/* general information */
task->data = data; /* user data */
/* temporary function for debbuging */
static void __SD_print_dependencies(SD_task_t 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;
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));
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) {
* \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;
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));
if (src == dst)
THROW1(arg_error, 0, "Cannot add a dependency between task '%s' and itself",
SD_task_get_name(src));
* \see SD_task_dependency_add()
*/
void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) {
* \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;
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) {
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) {
* \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;
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);
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"};
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"};
INFO2("Task '%s' watch points (%x): ", SD_task_get_name(task), task->watch_points);
INFO2("Task '%s' watch points (%x): ", SD_task_get_name(task), task->watch_points);
for (i = 0; i < 5; i++) {
if (task->watch_points & state_masks[i])
INFO1("%s ", state_names[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) {
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 */
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]);
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) {
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");
SD_CHECK_INIT_DONE();
xbt_assert0(task != NULL, "Invalid parameter");
xbt_assert0(workstation_nb > 0, "workstation_nb must be positive");
task->computation_amount = xbt_new(double, workstation_nb);
memcpy(task->computation_amount, computation_amount, sizeof(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;
+ 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->communication_amount = xbt_new(double, communication_nb);
memcpy(task->communication_amount, communication_amount, sizeof(double) * communication_nb);
* the task gets out of its fifos.
*/
void __SD_task_really_run(SD_task_t task) {
* 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));
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));
DEBUG1("Really running task '%s'", SD_task_get_name(task));
* Returns whether the task has started.
*/
int __SD_task_try_to_run(SD_task_t task) {
* 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));
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]);
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) {
* 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;
SD_workstation_t workstation;
SD_task_t candidate;
int candidate_nb = 0;
int candidate_capacity = 8;
SD_workstation_t workstation;
SD_task_t candidate;
int candidate_nb = 0;
int candidate_capacity = 8;
- SD_task_t *candidates = xbt_new(SD_task_t, 8);
+ 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;
__SD_task_set_state(task, SD_DONE);
surf_workstation_resource->common_public->action_free(task->surf_action);
task->surf_action = NULL;
/* Creates a workstation and registers it in SD.
*/
SD_workstation_t __SD_workstation_create(void *surf_workstation, void *data) {
/* Creates a workstation and registers it in SD.
*/
SD_workstation_t __SD_workstation_create(void *surf_workstation, void *data) {
+
+ SD_workstation_t workstation;
+ const char *name;
SD_CHECK_INIT_DONE();
xbt_assert0(surf_workstation != NULL, "surf_workstation is NULL !");
SD_CHECK_INIT_DONE();
xbt_assert0(surf_workstation != NULL, "surf_workstation is NULL !");
- SD_workstation_t workstation = xbt_new(s_SD_workstation_t, 1);
+ workstation = xbt_new(s_SD_workstation_t, 1);
workstation->surf_workstation = surf_workstation;
workstation->data = data; /* user data */
workstation->access_mode = SD_WORKSTATION_SHARED_ACCESS; /* default mode is shared */
workstation->task_fifo = NULL;
workstation->current_task = NULL;
workstation->surf_workstation = surf_workstation;
workstation->data = data; /* user data */
workstation->access_mode = SD_WORKSTATION_SHARED_ACCESS; /* default mode is shared */
workstation->task_fifo = NULL;
workstation->current_task = NULL;
- const char *name = SD_workstation_get_name(workstation);
+ name = SD_workstation_get_name(workstation);
xbt_dict_set(sd_global->workstations, name, workstation, __SD_workstation_destroy); /* add the workstation to the dictionary */
sd_global->workstation_count++;
xbt_dict_set(sd_global->workstations, name, workstation, __SD_workstation_destroy); /* add the workstation to the dictionary */
sd_global->workstation_count++;
* \see SD_workstation_get_number()
*/
const SD_workstation_t* SD_workstation_get_list(void) {
* \see SD_workstation_get_number()
*/
const SD_workstation_t* SD_workstation_get_list(void) {
- SD_CHECK_INIT_DONE();
- xbt_assert0(SD_workstation_get_number() > 0, "There is no workstation!");
xbt_dict_cursor_t cursor;
char *key;
void *data;
int i;
xbt_dict_cursor_t cursor;
char *key;
void *data;
int i;
+ SD_CHECK_INIT_DONE();
+ xbt_assert0(SD_workstation_get_number() > 0, "There is no workstation!");
+
+
+
if (sd_global->workstation_list == NULL) { /* this is the first time the function is called */
sd_global->workstation_list = xbt_new(SD_workstation_t, sd_global->workstation_count);
if (sd_global->workstation_list == NULL) { /* this is the first time the function is called */
sd_global->workstation_list = xbt_new(SD_workstation_t, sd_global->workstation_count);
* \see SD_route_get_size(), SD_link_t
*/
const SD_link_t* SD_route_get_list(SD_workstation_t src, SD_workstation_t dst) {
* \see SD_route_get_size(), SD_link_t
*/
const SD_link_t* SD_route_get_list(SD_workstation_t src, SD_workstation_t dst) {
+ void *surf_src;
+ void *surf_dst;
+ const void **surf_route;
+ int route_size;
+ const char *link_name;
+ int i;
+
SD_CHECK_INIT_DONE();
if (sd_global->recyclable_route == NULL) {
SD_CHECK_INIT_DONE();
if (sd_global->recyclable_route == NULL) {
sd_global->recyclable_route = xbt_new(SD_link_t, SD_link_get_number());
}
sd_global->recyclable_route = xbt_new(SD_link_t, SD_link_get_number());
}
- void *surf_src = src->surf_workstation;
- void *surf_dst = dst->surf_workstation;
+ surf_src = src->surf_workstation;
+ surf_dst = dst->surf_workstation;
+
+ surf_route = surf_workstation_resource->extension_public->get_route(surf_src, surf_dst);
+ route_size = surf_workstation_resource->extension_public->get_route_size(surf_src, surf_dst);
- const void **surf_route = surf_workstation_resource->extension_public->get_route(surf_src, surf_dst);
- int route_size = surf_workstation_resource->extension_public->get_route_size(surf_src, surf_dst);
- const char *link_name;
- int i;
for (i = 0; i < route_size; i++) {
link_name = surf_workstation_resource->extension_public->get_link_name(surf_route[i]);
sd_global->recyclable_route[i] = xbt_dict_get(sd_global->links, link_name);
for (i = 0; i < route_size; i++) {
link_name = surf_workstation_resource->extension_public->get_link_name(surf_route[i]);
sd_global->recyclable_route[i] = xbt_dict_get(sd_global->links, link_name);
* \see SD_route_get_current_bandwidth()
*/
double SD_route_get_current_latency(SD_workstation_t src, SD_workstation_t dst) {
* \see SD_route_get_current_bandwidth()
*/
double SD_route_get_current_latency(SD_workstation_t src, SD_workstation_t dst) {
+
+ const SD_link_t *links;
+ int nb_links;
+ double latency ;
+ int i;
+
SD_CHECK_INIT_DONE();
xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
SD_CHECK_INIT_DONE();
xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
- const SD_link_t *links = SD_route_get_list(src, dst);
- int nb_links = SD_route_get_size(src, dst);
- double latency = 0.0;
- int i;
+ links = SD_route_get_list(src, dst);
+ nb_links = SD_route_get_size(src, dst);
+ latency = 0.0;
for (i = 0; i < nb_links; i++) {
latency += SD_link_get_current_latency(links[i]);
for (i = 0; i < nb_links; i++) {
latency += SD_link_get_current_latency(links[i]);
* \see SD_route_get_current_latency()
*/
double SD_route_get_current_bandwidth(SD_workstation_t src, SD_workstation_t dst) {
* \see SD_route_get_current_latency()
*/
double SD_route_get_current_bandwidth(SD_workstation_t src, SD_workstation_t dst) {
+
+ const SD_link_t *links;
+ int nb_links;
+ double bandwidth;
+ double min_bandwidth;
+ int i;
+
SD_CHECK_INIT_DONE();
xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
SD_CHECK_INIT_DONE();
xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
- const SD_link_t *links = SD_route_get_list(src, dst);
- int nb_links = SD_route_get_size(src, dst);
- double bandwidth, min_bandwidth = -1.0;
- int i;
+
+ links = SD_route_get_list(src, dst);
+ nb_links = SD_route_get_size(src, dst);
+ bandwidth = min_bandwidth = -1.0;
+
for (i = 0; i < nb_links; i++) {
bandwidth = SD_link_get_current_bandwidth(links[i]);
for (i = 0; i < nb_links; i++) {
bandwidth = SD_link_get_current_bandwidth(links[i]);
*/
double SD_route_get_communication_time(SD_workstation_t src, SD_workstation_t dst,
double communication_amount) {
*/
double SD_route_get_communication_time(SD_workstation_t src, SD_workstation_t dst,
double communication_amount) {
/* total time = latency + transmission time of the slowest link
transmission time of a link = communication amount / link bandwidth */
/* total time = latency + transmission time of the slowest link
transmission time of a link = communication amount / link bandwidth */
- SD_CHECK_INIT_DONE();
- xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
- xbt_assert0(communication_amount >= 0, "communication_amount must be greater than or equal to zero");
const SD_link_t *links;
int nb_links;
double bandwidth, min_bandwidth;
double latency;
int i;
const SD_link_t *links;
int nb_links;
double bandwidth, min_bandwidth;
double latency;
int i;
+
+ SD_CHECK_INIT_DONE();
+ xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
+ xbt_assert0(communication_amount >= 0, "communication_amount must be greater than or equal to zero");
+
+
if (communication_amount == 0.0)
return 0.0;
if (communication_amount == 0.0)
return 0.0;
/* Destroys a workstation.
*/
void __SD_workstation_destroy(void *workstation) {
/* Destroys a workstation.
*/
void __SD_workstation_destroy(void *workstation) {
+
+ SD_workstation_t w;
+
SD_CHECK_INIT_DONE();
xbt_assert0(workstation != NULL, "Invalid parameter");
/* workstation->surf_workstation is freed by surf_exit and workstation->data is freed by the user */
SD_CHECK_INIT_DONE();
xbt_assert0(workstation != NULL, "Invalid parameter");
/* workstation->surf_workstation is freed by surf_exit and workstation->data is freed by the user */
- SD_workstation_t w = (SD_workstation_t) workstation;
+ w = (SD_workstation_t) workstation;
if (w->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
xbt_fifo_free(w->task_fifo);
if (w->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
xbt_fifo_free(w->task_fifo);