SMPI:
* Implement MPI_Waitany and MPI_Waitall
+ SURF:
+ * Factorize model_init/exit between models
+ * Declare common_public as an embeeded struct to reduce redirections
+ and mallocs
+
XBT:
* Add xbt_set_get_by_name_or_null() [Silas De Munck]
* Add xbt_graph_node_get_outedges() [Silas De Munck]
xbt/xbt_sg_time.c
SURF_SRC= \
+ surf/model.c \
surf/surf_config.c \
surf/maxmin.c \
surf/fair_bottleneck.c \
* the CPUs and the network links are examples of models.
*/
typedef struct surf_model {
+ s_surf_model_public_t common_public;
surf_model_private_t common_private;
- surf_model_public_t common_public;
} s_surf_model_t;
+ void surf_model_init(surf_model_t model);
+ void surf_model_exit(surf_model_t model);
+
+
/**************************************/
/* Implementations of model object */
/**************************************/
* \ingroup SURF_models
*/
typedef struct surf_timer_model {
+ s_surf_model_public_t common_public;
surf_model_private_t common_private;
- surf_model_public_t common_public;
surf_timer_model_extension_public_t extension_public;
} s_surf_timer_model_t, *surf_timer_model_t;
* \ingroup SURF_models
*/
typedef struct surf_cpu_model {
+ s_surf_model_public_t common_public;
surf_model_private_t common_private;
- surf_model_public_t common_public;
surf_cpu_model_extension_public_t extension_public;
} s_surf_cpu_model_t, *surf_cpu_model_t;
* \ingroup SURF_models
*/
typedef struct surf_network_model {
+ s_surf_model_public_t common_public;
surf_model_private_t common_private;
- surf_model_public_t common_public;
surf_network_model_extension_public_t extension_public;
} s_surf_network_model_t, *surf_network_model_t;
*
*/
typedef struct surf_workstation_model {
+ s_surf_model_public_t common_public;
surf_model_private_t common_private;
- surf_model_public_t common_public;
surf_workstation_model_extension_public_t extension_public;
} s_surf_workstation_model_t, *surf_workstation_model_t;
/* let's see which tasks are done */
xbt_dynar_foreach(model_list, iter, model) {
while ((action =
- xbt_swag_extract(model->common_public->states.
+ xbt_swag_extract(model->common_public.states.
done_action_set))) {
task = action->data;
INFO1("Task '%s' done", SD_task_get_name(task));
/* let's see which tasks have just failed */
while ((action =
- xbt_swag_extract(model->common_public->states.
+ xbt_swag_extract(model->common_public.states.
failed_action_set))) {
task = action->data;
INFO1("Task '%s' failed", SD_task_get_name(task));
__SD_task_set_state(task, SD_FAILED);
- surf_workstation_model->common_public->action_free(action);
+ surf_workstation_model->common_public.action_free(action);
task->surf_action = NULL;
if (!xbt_dynar_member(changed_tasks, &task))
SD_CHECK_INIT_DONE();
xbt_assert0((link != NULL), "Invalid parameters");
- return (surf_workstation_model->common_public->
+ return (surf_workstation_model->common_public.
get_properties(link->surf_link));
}
case SD_RUNNING:
task->state_set = sd_global->running_task_set;
task->start_time =
- surf_workstation_model->common_public->action_get_start_time(task->
+ surf_workstation_model->common_public.action_get_start_time(task->
surf_action);
break;
case SD_DONE:
task->state_set = sd_global->done_task_set;
task->finish_time =
- surf_workstation_model->common_public->action_get_finish_time(task->
+ surf_workstation_model->common_public.action_get_finish_time(task->
surf_action);
task->remains = 0;
break;
if (xbt_dynar_length(dst->tasks_before) == 0 && __SD_task_is_scheduled(dst))
__SD_task_set_state(dst, SD_READY);
- /* __SD_print_dependencies(src);
+ /* __SD_print_dependencies(src);
__SD_print_dependencies(dst); */
}
* SD_simulate() will stop as soon as the \ref e_SD_task_state_t "state" of this
* task becomes the one given in argument. The
* watch point is then automatically removed.
- *
+ *
* \param task a task
* \param state the \ref e_SD_task_state_t "state" you want to watch
* (cannot be #SD_NOT_SCHEDULED)
/**
* \brief Removes a watch point from a task
- *
+ *
* \param task a task
* \param state the \ref e_SD_task_state_t "state" you no longer want to watch
* \see SD_task_watch()
/**
* \brief Returns an approximative estimation of the execution time of a task.
- *
+ *
* The estimation is very approximative because the value returned is the time
* the task would take if it was executed now and if it was the only task.
- *
+ *
* \param task the task to evaluate
* \param workstation_nb number of workstations on which the task would be executed
* \param workstation_list the workstations on which the task would be executed
* The task state must be #SD_NOT_SCHEDULED.
* Once scheduled, a task will be executed as soon as possible in SD_simulate(),
* i.e. when its dependencies are satisfied.
- *
+ *
* \param task the task you want to schedule
* \param workstation_nb number of workstations on which the task will be executed
* \param workstation_list the workstations on which the task will be executed
__SD_task_destroy_scheduling_data(task);
if (__SD_task_is_running(task)) /* the task should become SD_FAILED */
- surf_workstation_model->common_public->action_cancel(task->surf_action);
+ surf_workstation_model->common_public.action_cancel(task->surf_action);
else
__SD_task_set_state(task, SD_NOT_SCHEDULED);
task->remains = task->amount;
xbt_free(surf_workstations);
}
- surf_workstation_model->common_public->action_set_data(task->surf_action,
+ surf_workstation_model->common_public.action_set_data(task->surf_action,
task);
DEBUG1("surf_action = %p", task->surf_action);
candidates = xbt_new(SD_task_t, 8);
__SD_task_set_state(task, SD_DONE);
- surf_workstation_model->common_public->action_free(task->surf_action);
+ surf_workstation_model->common_public.action_free(task->surf_action);
task->surf_action = NULL;
DEBUG0("Looking for candidates");
SD_CHECK_INIT_DONE();
xbt_assert0(task != NULL, "Invalid parameter");
if (task->surf_action)
- return surf_workstation_model->common_public->action_get_start_time(task->
+ return surf_workstation_model->common_public.action_get_start_time(task->
surf_action);
else
return task->start_time;
*
* The task state must be SD_RUNNING, SD_DONE or SD_FAILED.
* If the state is not completed yet, the returned value is an
- * estimation of the task finish time. This value can fluctuate
+ * estimation of the task finish time. This value can fluctuate
* until the task is completed.
*
* \param task: a task
xbt_assert0(task != NULL, "Invalid parameter");
if (task->surf_action) /* should never happen as actions are destroyed right after their completion */
- return surf_workstation_model->common_public->
+ return surf_workstation_model->common_public.
action_get_finish_time(task->surf_action);
else
return task->finish_time;
xbt_free(task->name);
if (task->surf_action != NULL)
- surf_workstation_model->common_public->action_free(task->surf_action);
+ surf_workstation_model->common_public.action_free(task->surf_action);
if (task->workstation_list != NULL)
xbt_free(task->workstation_list);
{
SD_CHECK_INIT_DONE();
xbt_assert0(workstation != NULL, "Invalid parameter");
- return surf_workstation_model->common_public->
+ return surf_workstation_model->common_public.
get_resource_name(workstation->surf_workstation);
}
SD_CHECK_INIT_DONE();
xbt_assert0((workstation != NULL), "Invalid parameters");
- return (surf_workstation_model->common_public->
+ return (surf_workstation_model->common_public.
get_properties(workstation->surf_workstation));
}
/************************************* Actions *********************************/
/** \brief Creates a new SIMIX action to communicate two hosts.
*
- * This function creates a SURF action and allocates the data necessary to create the SIMIX action. It can raise a network_error exception if the host is unavailable.
+ * This function creates a SURF action and allocates the data necessary to create the SIMIX action. It can raise a network_error exception if the host is unavailable.
* \param sender SIMIX host sender
* \param receiver SIMIX host receiver
* \param name Action name
host,
receiver->simdata->
host, size, rate);
- surf_workstation_model->common_public->action_set_data(simdata->surf_action,
+ surf_workstation_model->common_public.action_set_data(simdata->surf_action,
act);
DEBUG1("Create communicate action %p", act);
/** \brief Creates a new SIMIX action to execute an action.
*
- * This function creates a SURF action and allocates the data necessary to create the SIMIX action. It can raise a host_error exception if the host crashed.
+ * This function creates a SURF action and allocates the data necessary to create the SIMIX action. It can raise a host_error exception if the host crashed.
* \param host SIMIX host where the action will be executed
* \param name Action name
* \param amount Task amount (in bytes)
surf_workstation_model->extension_public->execute(host->simdata->host,
amount);
- surf_workstation_model->common_public->action_set_data(simdata->surf_action,
+ surf_workstation_model->common_public.action_set_data(simdata->surf_action,
act);
DEBUG1("Create execute action %p", act);
/** \brief Creates a new sleep SIMIX action.
*
- * This function creates a SURF action and allocates the data necessary to create the SIMIX action. It can raise a host_error exception if the host crashed. The default SIMIX name of the action is "sleep".
+ * This function creates a SURF action and allocates the data necessary to create the SIMIX action. It can raise a host_error exception if the host crashed. The default SIMIX name of the action is "sleep".
* \param host SIMIX host where the sleep will run.
* \param duration Time duration of the sleep.
* \return A new SIMIX action
surf_workstation_model->extension_public->sleep(host->simdata->host,
duration);
- surf_workstation_model->common_public->action_set_data(simdata->surf_action,
+ surf_workstation_model->common_public.action_set_data(simdata->surf_action,
act);
DEBUG1("Create sleep action %p", act);
DEBUG1("Cancel action %p", action);
if (action->simdata->surf_action) {
- surf_workstation_model->common_public->action_cancel(action->
+ surf_workstation_model->common_public.action_cancel(action->
simdata->
surf_action);
}
xbt_assert0((action != NULL)
&& (action->simdata != NULL), "Invalid parameter");
- surf_workstation_model->common_public->set_priority(action->simdata->
+ surf_workstation_model->common_public.set_priority(action->simdata->
surf_action, priority);
return;
}
/**
* \brief Destroys an action
*
- * Destroys an action, freing its memory. This function cannot be called if there are a conditional waiting for it.
+ * Destroys an action, freing its memory. This function cannot be called if there are a conditional waiting for it.
* \param action The SIMIX action
*/
int SIMIX_action_destroy(smx_action_t action)
if (action->simdata->surf_action)
action->simdata->surf_action->model_type->
- common_public->action_free(action->simdata->surf_action);
+ common_public.action_free(action->simdata->surf_action);
xbt_free(action->simdata);
xbt_free(action);
/**
* \brief Set an action to a condition
*
- * Creates the "link" between an action and a condition. You have to call this function when you create an action and want to wait its ending.
+ * Creates the "link" between an action and a condition. You have to call this function when you create an action and want to wait its ending.
* \param action SIMIX action
* \param cond SIMIX cond
*/
amount,
rate);
- surf_workstation_model->common_public->action_set_data(simdata->surf_action,
+ surf_workstation_model->common_public.action_set_data(simdata->surf_action,
act);
return act;
e_surf_action_state_t SIMIX_action_get_state(smx_action_t action)
{
xbt_assert0((action != NULL), "Invalid parameter");
- return surf_workstation_model->common_public->action_get_state(action->
+ return surf_workstation_model->common_public.action_get_state(action->
simdata->
surf_action);
void *arg = NULL;
xbt_dynar_foreach(model_list, iter, model) {
- if (xbt_swag_size(model->common_public->states.failed_action_set)
- || xbt_swag_size(model->common_public->states.done_action_set)) {
+ if (xbt_swag_size(model->common_public.states.failed_action_set)
+ || xbt_swag_size(model->common_public.states.done_action_set)) {
state_modifications = 1;
break;
}
/* Wake up all process waiting for the action finish */
xbt_dynar_foreach(model_list, iter, model) {
while ((action =
- xbt_swag_extract(model->common_public->
+ xbt_swag_extract(model->common_public.
states.failed_action_set))) {
smx_action = action->data;
if (smx_action) {
}
}
while ((action =
- xbt_swag_extract(model->common_public->
+ xbt_swag_extract(model->common_public.
states.done_action_set))) {
smx_action = action->data;
if (smx_action) {
return host;
}
-/**
+/**
* \brief Set the user data of a #smx_host_t.
*
* This functions checks whether some data has already been associated to \a host or not and attach \a data to \a host if it is possible.
return (host->data);
}
-/**
+/**
* \brief Return the name of the #smx_host_t.
*
* This functions checks whether \a host is a valid pointer or not and return its name.
return (host->name);
}
-/**
+/**
* \brief Return the location on which the current process is executed.
*
* Return the host, more details in #SIMIX_process_get_host
/*
* Real function for destroy a host.
- * MSG_host_destroy is just a front_end that also removes it from
+ * MSG_host_destroy is just a front_end that also removes it from
* msg_global->host
*/
void __SIMIX_host_destroy(void *h)
{
xbt_assert0((host != NULL), "Invalid parameters");
- return (surf_workstation_model->common_public->
+ return (surf_workstation_model->common_public.
get_properties(host->simdata->host));
}
simdata->suspended = 1;
c = simdata->cond;
xbt_fifo_foreach(c->actions, i, act, smx_action_t) {
- surf_workstation_model->common_public->suspend(act->
+ surf_workstation_model->common_public.suspend(act->
simdata->surf_action);
}
} else {
cond = SIMIX_cond_init();
dummy = SIMIX_action_execute(SIMIX_process_get_host(process), name, 0);
- surf_workstation_model->common_public->suspend(dummy->simdata->
+ surf_workstation_model->common_public.suspend(dummy->simdata->
surf_action);
SIMIX_register_action_to_condition(dummy, cond);
__SIMIX_cond_wait(cond);
simdata->suspended = 0;
c = simdata->cond;
xbt_fifo_foreach(c->actions, i, act, smx_action_t) {
- surf_workstation_model->common_public->resume(act->simdata->
+ surf_workstation_model->common_public.resume(act->simdata->
surf_action);
}
SIMIX_cond_signal(c);
return;
}
-static void action_recycle(surf_action_t action)
-{
- DIE_IMPOSSIBLE;
-}
-
static void action_change_state(surf_action_t action,
e_surf_action_state_t state)
{
static double share_resources(double now)
{
s_surf_action_cpu_Cas01_t action;
- return generic_maxmin_share_resources(surf_cpu_model->common_public->states.
+ return generic_maxmin_share_resources(surf_cpu_model->common_public.states.
running_action_set,
xbt_swag_offset(action, variable),
cpu_maxmin_system, lmm_solve);
surf_action_cpu_Cas01_t action = NULL;
surf_action_cpu_Cas01_t next_action = NULL;
xbt_swag_t running_actions =
- surf_cpu_model->common_public->states.running_action_set;
+ surf_cpu_model->common_public.states.running_action_set;
/* FIXME: UNUSED
xbt_swag_t failed_actions =
- surf_cpu_model->common_public->states.failed_action_set;
+ surf_cpu_model->common_public.states.failed_action_set;
*/
xbt_swag_foreach_safe(action, next_action, running_actions) {
if (CPU->state_current == SURF_CPU_ON)
action->generic_action.state_set =
- surf_cpu_model->common_public->states.running_action_set;
+ surf_cpu_model->common_public.states.running_action_set;
else
action->generic_action.state_set =
- surf_cpu_model->common_public->states.failed_action_set;
+ surf_cpu_model->common_public.states.failed_action_set;
xbt_swag_insert(action, action->generic_action.state_set);
xbt_dict_free(&cpu_set);
lmm_system_free(cpu_maxmin_system);
cpu_maxmin_system = NULL;
- xbt_swag_free(surf_cpu_model->common_public->states.ready_action_set);
- xbt_swag_free(surf_cpu_model->common_public->states.running_action_set);
- xbt_swag_free(surf_cpu_model->common_public->states.failed_action_set);
- xbt_swag_free(surf_cpu_model->common_public->states.done_action_set);
+
+ surf_model_exit((surf_model_t) surf_cpu_model);
+
xbt_swag_free(running_action_set_that_does_not_need_being_checked);
running_action_set_that_does_not_need_being_checked = NULL;
- free(surf_cpu_model->common_public);
- free(surf_cpu_model->common_private);
free(surf_cpu_model->extension_public);
free(surf_cpu_model);
surf_cpu_model = xbt_new0(s_surf_cpu_model_t, 1);
- surf_cpu_model->common_private = xbt_new0(s_surf_model_private_t, 1);
- surf_cpu_model->common_public = xbt_new0(s_surf_model_public_t, 1);
+ surf_model_init((surf_model_t) surf_cpu_model);
surf_cpu_model->extension_public =
xbt_new0(s_surf_cpu_model_extension_public_t, 1);
- surf_cpu_model->common_public->states.ready_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_cpu_model->common_public->states.running_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_cpu_model->common_public->states.failed_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_cpu_model->common_public->states.done_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
-
running_action_set_that_does_not_need_being_checked =
xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_cpu_model->common_public->name_service = name_service;
- surf_cpu_model->common_public->get_resource_name = get_resource_name;
- surf_cpu_model->common_public->action_get_state = surf_action_get_state;
- surf_cpu_model->common_public->action_get_start_time =
+ surf_cpu_model->common_public.name_service = name_service;
+ surf_cpu_model->common_public.get_resource_name = get_resource_name;
+ surf_cpu_model->common_public.action_get_state = surf_action_get_state;
+ surf_cpu_model->common_public.action_get_start_time =
surf_action_get_start_time;
- surf_cpu_model->common_public->action_get_finish_time =
+ surf_cpu_model->common_public.action_get_finish_time =
surf_action_get_finish_time;
- surf_cpu_model->common_public->action_free = action_free;
- surf_cpu_model->common_public->action_use = action_use;
- surf_cpu_model->common_public->action_cancel = action_cancel;
- surf_cpu_model->common_public->action_recycle = action_recycle;
- surf_cpu_model->common_public->action_change_state = action_change_state;
- surf_cpu_model->common_public->action_set_data = surf_action_set_data;
- surf_cpu_model->common_public->name = "CPU";
+ surf_cpu_model->common_public.action_free = action_free;
+ surf_cpu_model->common_public.action_use = action_use;
+ surf_cpu_model->common_public.action_cancel = action_cancel;
+ surf_cpu_model->common_public.action_change_state = action_change_state;
+ surf_cpu_model->common_public.action_set_data = surf_action_set_data;
+ surf_cpu_model->common_public.name = "CPU";
surf_cpu_model->common_private->resource_used = resource_used;
surf_cpu_model->common_private->share_resources = share_resources;
update_resource_state;
surf_cpu_model->common_private->finalize = finalize;
- surf_cpu_model->common_public->suspend = action_suspend;
- surf_cpu_model->common_public->resume = action_resume;
- surf_cpu_model->common_public->is_suspended = action_is_suspended;
- surf_cpu_model->common_public->set_max_duration = action_set_max_duration;
- surf_cpu_model->common_public->set_priority = action_set_priority;
+ surf_cpu_model->common_public.suspend = action_suspend;
+ surf_cpu_model->common_public.resume = action_resume;
+ surf_cpu_model->common_public.is_suspended = action_is_suspended;
+ surf_cpu_model->common_public.set_max_duration = action_set_max_duration;
+ surf_cpu_model->common_public.set_priority = action_set_priority;
surf_cpu_model->extension_public->execute = execute;
surf_cpu_model->extension_public->sleep = action_sleep;
surf_cpu_model->extension_public->get_speed = get_speed;
surf_cpu_model->extension_public->get_available_speed = get_available_speed;
/*manage the properties of the cpu */
- surf_cpu_model->common_public->get_properties = get_properties;
+ surf_cpu_model->common_public.get_properties = get_properties;
if (!cpu_set)
cpu_set = xbt_dict_new();
--- /dev/null
+
+/* Copyright (c) 2009 The SimGrid Team. All rights reserved. */
+
+/* This program is free software; you can redistribute it and/or modify it
+ * under the terms of the license (GNU LGPL) which comes with this package. */
+
+#include "surf_private.h"
+
+static void void_die_impossible_paction(surf_action_t action) {
+ DIE_IMPOSSIBLE;
+}
+static int int_die_impossible_paction(surf_action_t action) {
+ DIE_IMPOSSIBLE;
+}
+
+/** @brief initialize common datastructures to all models */
+void surf_model_init(surf_model_t model) {
+ s_surf_action_t action;
+
+
+ model->common_private = xbt_new0(s_surf_model_private_t, 1);
+
+ model->common_public.states.ready_action_set =
+ xbt_swag_new(xbt_swag_offset(action, state_hookup));
+ model->common_public.states.running_action_set =
+ xbt_swag_new(xbt_swag_offset(action, state_hookup));
+ model->common_public.states.failed_action_set =
+ xbt_swag_new(xbt_swag_offset(action, state_hookup));
+ model->common_public.states.done_action_set =
+ xbt_swag_new(xbt_swag_offset(action, state_hookup));
+
+ model->common_public.action_free = int_die_impossible_paction;
+ model->common_public.action_cancel = void_die_impossible_paction;
+ model->common_public.action_recycle = void_die_impossible_paction;
+
+}
+
+
+/** @brief finalize common datastructures to all models */
+void surf_model_exit(surf_model_t model) {
+ xbt_swag_free(model->common_public.states.ready_action_set);
+ xbt_swag_free(model->common_public.states.running_action_set);
+ xbt_swag_free(model->common_public.states.failed_action_set);
+ xbt_swag_free(model->common_public.states.done_action_set);
+ free(model->common_private);
+}
s_surf_action_network_CM02_t s_action;
surf_action_network_CM02_t action = NULL;
xbt_swag_t running_actions =
- surf_network_model->common_public->states.running_action_set;
+ surf_network_model->common_public.states.running_action_set;
double min;
min = generic_maxmin_share_resources(running_actions,
surf_action_network_CM02_t action = NULL;
surf_action_network_CM02_t next_action = NULL;
xbt_swag_t running_actions =
- surf_network_model->common_public->states.running_action_set;
+ surf_network_model->common_public.states.running_action_set;
/*
xbt_swag_t failed_actions =
- surf_network_model->common_public->states.failed_action_set;
+ surf_network_model->common_public.states.failed_action_set;
*/
xbt_swag_foreach_safe(action, next_action, running_actions) {
action->suspended = 0; /* Should be useless because of the
calloc but it seems to help valgrind... */
action->generic_action.state_set =
- surf_network_model->common_public->states.running_action_set;
+ surf_network_model->common_public.states.running_action_set;
for (i = 0; i < route_size; i++)
if (route[i]->state_current == SURF_LINK_OFF) {
action->generic_action.state_set =
- surf_network_model->common_public->states.failed_action_set;
+ surf_network_model->common_public.states.failed_action_set;
break;
}
xbt_dict_free(&network_card_set);
xbt_dict_free(&link_set);
- xbt_swag_free(surf_network_model->common_public->states.ready_action_set);
- xbt_swag_free(surf_network_model->common_public->states.running_action_set);
- xbt_swag_free(surf_network_model->common_public->states.failed_action_set);
- xbt_swag_free(surf_network_model->common_public->states.done_action_set);
- free(surf_network_model->common_public);
- free(surf_network_model->common_private);
- free(surf_network_model->extension_public);
+ surf_model_exit((surf_model_t)surf_network_model);
+
+ free(surf_network_model->extension_public);
free(surf_network_model);
surf_network_model = NULL;
static void surf_network_model_init_internal(void)
{
- s_surf_action_t action;
-
surf_network_model = xbt_new0(s_surf_network_model_t, 1);
- surf_network_model->common_private = xbt_new0(s_surf_model_private_t, 1);
- surf_network_model->common_public = xbt_new0(s_surf_model_public_t, 1);
+ surf_model_init((surf_model_t)surf_network_model);
+
surf_network_model->extension_public =
xbt_new0(s_surf_network_model_extension_public_t, 1);
- surf_network_model->common_public->states.ready_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_network_model->common_public->states.running_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_network_model->common_public->states.failed_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_network_model->common_public->states.done_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
-
- surf_network_model->common_public->name_service = name_service;
- surf_network_model->common_public->get_resource_name = get_resource_name;
- surf_network_model->common_public->action_get_state = surf_action_get_state;
- surf_network_model->common_public->action_get_start_time =
+ surf_network_model->common_public.name_service = name_service;
+ surf_network_model->common_public.get_resource_name = get_resource_name;
+ surf_network_model->common_public.action_get_state = surf_action_get_state;
+ surf_network_model->common_public.action_get_start_time =
surf_action_get_start_time;
- surf_network_model->common_public->action_get_finish_time =
+ surf_network_model->common_public.action_get_finish_time =
surf_action_get_finish_time;
- surf_network_model->common_public->action_free = action_free;
- surf_network_model->common_public->action_use = action_use;
- surf_network_model->common_public->action_cancel = action_cancel;
- surf_network_model->common_public->action_recycle = action_recycle;
- surf_network_model->common_public->action_change_state =
+ surf_network_model->common_public.action_free = action_free;
+ surf_network_model->common_public.action_use = action_use;
+ surf_network_model->common_public.action_cancel = action_cancel;
+ surf_network_model->common_public.action_recycle = action_recycle;
+ surf_network_model->common_public.action_change_state =
action_change_state;
- surf_network_model->common_public->action_set_data = surf_action_set_data;
- surf_network_model->common_public->name = "network";
+ surf_network_model->common_public.action_set_data = surf_action_set_data;
+ surf_network_model->common_public.name = "network";
surf_network_model->common_private->resource_used = resource_used;
surf_network_model->common_private->share_resources = share_resources;
update_resource_state;
surf_network_model->common_private->finalize = finalize;
- surf_network_model->common_public->suspend = action_suspend;
- surf_network_model->common_public->resume = action_resume;
- surf_network_model->common_public->is_suspended = action_is_suspended;
- surf_cpu_model->common_public->set_max_duration = action_set_max_duration;
+ surf_network_model->common_public.suspend = action_suspend;
+ surf_network_model->common_public.resume = action_resume;
+ surf_network_model->common_public.is_suspended = action_is_suspended;
+ surf_cpu_model->common_public.set_max_duration = action_set_max_duration;
surf_network_model->extension_public->communicate = communicate;
surf_network_model->extension_public->get_route = get_route;
surf_network_model->extension_public->get_link_latency = get_link_latency;
surf_network_model->extension_public->link_shared = link_shared;
- surf_network_model->common_public->get_properties = get_properties;
+ surf_network_model->common_public.get_properties = get_properties;
link_set = xbt_dict_new();
network_card_set = xbt_dict_new();
{
surf_action_network_Constant_t action = NULL;
xbt_swag_t running_actions =
- surf_network_model->common_public->states.running_action_set;
+ surf_network_model->common_public.states.running_action_set;
double min = -1.0;
xbt_swag_foreach(action, running_actions) {
surf_action_network_Constant_t action = NULL;
surf_action_network_Constant_t next_action = NULL;
xbt_swag_t running_actions =
- surf_network_model->common_public->states.running_action_set;
+ surf_network_model->common_public.states.running_action_set;
xbt_swag_foreach_safe(action, next_action, running_actions) {
if (action->latency > 0) {
if (action->latency <= 0.0)
action->generic_action.state_set =
- surf_network_model->common_public->states.done_action_set;
+ surf_network_model->common_public.states.done_action_set;
else
action->generic_action.state_set =
- surf_network_model->common_public->states.running_action_set;
+ surf_network_model->common_public.states.running_action_set;
xbt_swag_insert(action, action->generic_action.state_set);
static void finalize(void)
{
xbt_dict_free(&network_card_set);
- xbt_swag_free(surf_network_model->common_public->states.ready_action_set);
- xbt_swag_free(surf_network_model->common_public->states.running_action_set);
- xbt_swag_free(surf_network_model->common_public->states.failed_action_set);
- xbt_swag_free(surf_network_model->common_public->states.done_action_set);
- free(surf_network_model->common_public);
- free(surf_network_model->common_private);
+
+ surf_model_exit((surf_model_t)surf_network_model);
+
free(surf_network_model->extension_public);
free(surf_network_model);
static void surf_network_model_init_internal(void)
{
- s_surf_action_t action;
-
surf_network_model = xbt_new0(s_surf_network_model_t, 1);
- surf_network_model->common_private = xbt_new0(s_surf_model_private_t, 1);
- surf_network_model->common_public = xbt_new0(s_surf_model_public_t, 1);
+ surf_model_init((surf_model_t)surf_network_model);
+
surf_network_model->extension_public =
xbt_new0(s_surf_network_model_extension_public_t, 1);
- surf_network_model->common_public->states.ready_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_network_model->common_public->states.running_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_network_model->common_public->states.failed_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_network_model->common_public->states.done_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
-
- surf_network_model->common_public->name_service = name_service;
- surf_network_model->common_public->get_resource_name = get_resource_name;
- surf_network_model->common_public->action_get_state = surf_action_get_state;
- surf_network_model->common_public->action_get_start_time =
+ surf_network_model->common_public.name_service = name_service;
+ surf_network_model->common_public.get_resource_name = get_resource_name;
+ surf_network_model->common_public.action_get_state = surf_action_get_state;
+ surf_network_model->common_public.action_get_start_time =
surf_action_get_start_time;
- surf_network_model->common_public->action_get_finish_time =
+ surf_network_model->common_public.action_get_finish_time =
surf_action_get_finish_time;
- surf_network_model->common_public->action_free = action_free;
- surf_network_model->common_public->action_use = action_use;
- surf_network_model->common_public->action_cancel = action_cancel;
- surf_network_model->common_public->action_recycle = action_recycle;
- surf_network_model->common_public->action_change_state =
+ surf_network_model->common_public.action_free = action_free;
+ surf_network_model->common_public.action_use = action_use;
+ surf_network_model->common_public.action_cancel = action_cancel;
+ surf_network_model->common_public.action_recycle = action_recycle;
+ surf_network_model->common_public.action_change_state =
action_change_state;
- surf_network_model->common_public->action_set_data = surf_action_set_data;
- surf_network_model->common_public->name = "network";
+ surf_network_model->common_public.action_set_data = surf_action_set_data;
+ surf_network_model->common_public.name = "network";
surf_network_model->common_private->resource_used = resource_used;
surf_network_model->common_private->share_resources = share_resources;
update_resource_state;
surf_network_model->common_private->finalize = finalize;
- surf_network_model->common_public->suspend = action_suspend;
- surf_network_model->common_public->resume = action_resume;
- surf_network_model->common_public->is_suspended = action_is_suspended;
- surf_cpu_model->common_public->set_max_duration = action_set_max_duration;
+ surf_network_model->common_public.suspend = action_suspend;
+ surf_network_model->common_public.resume = action_resume;
+ surf_network_model->common_public.is_suspended = action_is_suspended;
+ surf_cpu_model->common_public.set_max_duration = action_set_max_duration;
surf_network_model->extension_public->communicate = communicate;
surf_network_model->extension_public->get_route = get_route;
surf_network_model->extension_public->get_link_latency = get_link_latency;
surf_network_model->extension_public->link_shared = link_shared;
- surf_network_model->common_public->get_properties = get_properties;
+ surf_network_model->common_public.get_properties = get_properties;
network_card_set = xbt_dict_new();
static double share_resources(double now)
{
xbt_swag_t running_actions =
- surf_network_model->common_public->states.running_action_set;
+ surf_network_model->common_public.states.running_action_set;
//get the first relevant value from the running_actions list
if (!xbt_swag_size(running_actions))
/* delta: by how many time units the simulation must advance */
/* In this function: change the state of actions that terminate */
-/* The delta may not come from the network, and thus may be different (smaller)
+/* The delta may not come from the network, and thus may be different (smaller)
than the one returned by the function above */
/* If the delta is a network-caused min, then do not emulate any timer in the
network simulation, otherwise fake a timer somehow to advance the simulation of min seconds */
surf_action_network_GTNETS_t action = NULL;
// surf_action_network_GTNETS_t next_action = NULL;
xbt_swag_t running_actions =
- surf_network_model->common_public->states.running_action_set;
+ surf_network_model->common_public.states.running_action_set;
/* If there are no renning flows, just return */
if (time_to_next_flow_completion < 0.0) {
action->generic_action.model_type = (surf_model_t) surf_network_model;
action->generic_action.state_set =
- surf_network_model->common_public->states.running_action_set;
+ surf_network_model->common_public.states.running_action_set;
xbt_swag_insert(action, action->generic_action.state_set);
static void finalize(void)
{
-#if 0
- int i, j;
-#endif
xbt_dict_free(&network_card_set);
xbt_dict_free(&link_set);
- xbt_swag_free(surf_network_model->common_public->states.ready_action_set);
- xbt_swag_free(surf_network_model->common_public->states.running_action_set);
- xbt_swag_free(surf_network_model->common_public->states.failed_action_set);
- xbt_swag_free(surf_network_model->common_public->states.done_action_set);
- free(surf_network_model->common_public);
- free(surf_network_model->common_private);
+
+ surf_model_exit((surf_model_t)surf_network_model);
+
free(surf_network_model->extension_public);
free(surf_network_model);
surf_network_model = xbt_new0(s_surf_network_model_t, 1);
- surf_network_model->common_private = xbt_new0(s_surf_model_private_t, 1);
- surf_network_model->common_public = xbt_new0(s_surf_model_public_t, 1);
+ surf_model_init((surf_model_t)surf_network_model);
+
surf_network_model->extension_public =
xbt_new0(s_surf_network_model_extension_public_t, 1);
- surf_network_model->common_public->states.ready_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_network_model->common_public->states.running_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_network_model->common_public->states.failed_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_network_model->common_public->states.done_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
-
- surf_network_model->common_public->name_service = name_service;
- surf_network_model->common_public->get_resource_name = get_resource_name;
- surf_network_model->common_public->action_get_state = surf_action_get_state;
- surf_network_model->common_public->action_use = action_use;
- surf_network_model->common_public->action_free = action_free;
- surf_network_model->common_public->action_cancel = action_cancel;
- surf_network_model->common_public->action_recycle = action_recycle;
- surf_network_model->common_public->action_change_state =
+ surf_network_model->common_public.name_service = name_service;
+ surf_network_model->common_public.get_resource_name = get_resource_name;
+ surf_network_model->common_public.action_get_state = surf_action_get_state;
+ surf_network_model->common_public.action_use = action_use;
+ surf_network_model->common_public.action_free = action_free;
+ surf_network_model->common_public.action_cancel = action_cancel;
+ surf_network_model->common_public.action_recycle = action_recycle;
+ surf_network_model->common_public.action_change_state =
action_change_state;
- surf_network_model->common_public->action_set_data = surf_action_set_data;
- surf_network_model->common_public->name = "network";
+ surf_network_model->common_public.action_set_data = surf_action_set_data;
+ surf_network_model->common_public.name = "network";
surf_network_model->common_private->resource_used = resource_used;
surf_network_model->common_private->share_resources = share_resources;
update_resource_state;
surf_network_model->common_private->finalize = finalize;
- surf_network_model->common_public->suspend = action_suspend;
- surf_network_model->common_public->resume = action_resume;
- surf_network_model->common_public->is_suspended = action_is_suspended;
+ surf_network_model->common_public.suspend = action_suspend;
+ surf_network_model->common_public.resume = action_resume;
+ surf_network_model->common_public.is_suspended = action_is_suspended;
surf_network_model->extension_public->communicate = communicate;
/*for the props of the link */
- surf_network_model->common_public->get_properties = get_properties;
+ surf_network_model->common_public.get_properties = get_properties;
link_set = xbt_dict_new();
network_card_set = xbt_dict_new();
e_surf_action_state_t surf_action_get_state(surf_action_t action)
{
surf_action_state_t action_state =
- &(action->model_type->common_public->states);
+ &(action->model_type->common_public.states);
if (action->state_set == action_state->ready_action_set)
return SURF_ACTION_READY;
void surf_action_free(surf_action_t * action)
{
- (*action)->model_type->common_public->action_cancel(*action);
+ (*action)->model_type->common_public.action_cancel(*action);
free(*action);
*action = NULL;
}
e_surf_action_state_t state)
{
surf_action_state_t action_state =
- &(action->model_type->common_public->states);
+ &(action->model_type->common_public.states);
XBT_IN2("(%p,%s)", action, surf_action_state_names[state]);
xbt_swag_remove(action, action->state_set);
DEBUG0("Looking for next action end");
xbt_dynar_foreach(model_list, iter, model) {
- DEBUG1("Running for Resource [%s]", model->common_public->name);
+ DEBUG1("Running for Resource [%s]", model->common_public.name);
model_next_action_end = model->common_private->share_resources(NOW);
DEBUG2("Resource [%s] : next action end = %f",
- model->common_public->name, model_next_action_end);
+ model->common_public.name, model_next_action_end);
if (((min < 0.0) || (model_next_action_end < min))
&& (model_next_action_end >= 0.0))
min = model_next_action_end;
typedef struct surf_model_private {
int (*resource_used) (void *resource_id);
- /* Share the resources to the actions and return in hom much time
+ /* Share the resources to the actions and return in how much time
the next action may terminate */
double (*share_resources) (double now);
/* Update the actions' state */
lmm_system_t sys,
void (*solve) (lmm_system_t));
-/* Generic functions common to all modelss */
+/* Generic functions common to all models */
e_surf_action_state_t surf_action_get_state(surf_action_t action);
double surf_action_get_start_time(surf_action_t action);
double surf_action_get_finish_time(surf_action_t action);
return 1;
}
-static int action_free(surf_action_t action)
-{
- DIE_IMPOSSIBLE;
- return 1;
-}
-
-static void action_cancel(surf_action_t action)
-{
- DIE_IMPOSSIBLE;
- return;
-}
-
-static void action_recycle(surf_action_t action)
-{
- DIE_IMPOSSIBLE;
- return;
-}
-
static void action_change_state(surf_action_t action,
e_surf_action_state_t state)
{
xbt_swag_free(command_pending);
xbt_swag_free(command_to_run);
- xbt_swag_free(surf_timer_model->common_public->states.ready_action_set);
- xbt_swag_free(surf_timer_model->common_public->states.running_action_set);
- xbt_swag_free(surf_timer_model->common_public->states.failed_action_set);
- xbt_swag_free(surf_timer_model->common_public->states.done_action_set);
- free(surf_timer_model->common_public);
- free(surf_timer_model->common_private);
+ surf_model_exit((surf_model_t)surf_timer_model);
+
free(surf_timer_model->extension_public);
free(surf_timer_model);
static void surf_timer_model_init_internal(void)
{
- s_surf_action_t action;
-
surf_timer_model = xbt_new0(s_surf_timer_model_t, 1);
- surf_timer_model->common_private = xbt_new0(s_surf_model_private_t, 1);
- surf_timer_model->common_public = xbt_new0(s_surf_model_public_t, 1);
+ surf_model_init((surf_model_t)surf_timer_model);
surf_timer_model->extension_public =
xbt_new0(s_surf_timer_model_extension_public_t, 1);
- surf_timer_model->common_public->states.ready_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_timer_model->common_public->states.running_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_timer_model->common_public->states.failed_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_timer_model->common_public->states.done_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
-
- surf_timer_model->common_public->name_service = name_service;
- surf_timer_model->common_public->get_resource_name = get_resource_name;
- surf_timer_model->common_public->action_get_state = surf_action_get_state;
- surf_timer_model->common_public->action_free = action_free;
- surf_timer_model->common_public->action_cancel = action_cancel;
- surf_timer_model->common_public->action_recycle = action_recycle;
- surf_timer_model->common_public->action_change_state = action_change_state;
- surf_timer_model->common_public->action_set_data = surf_action_set_data;
- surf_timer_model->common_public->name = "TIMER";
+ surf_timer_model->common_public.name_service = name_service;
+ surf_timer_model->common_public.get_resource_name = get_resource_name;
+ surf_timer_model->common_public.action_get_state = surf_action_get_state;
+ surf_timer_model->common_public.action_change_state = action_change_state;
+ surf_timer_model->common_public.action_set_data = surf_action_set_data;
+ surf_timer_model->common_public.name = "TIMER";
surf_timer_model->common_private->resource_used = resource_used;
surf_timer_model->common_private->share_resources = share_resources;
update_resource_state;
surf_timer_model->common_private->finalize = finalize;
- surf_timer_model->common_public->suspend = action_suspend;
- surf_timer_model->common_public->resume = action_resume;
- surf_timer_model->common_public->is_suspended = action_is_suspended;
+ surf_timer_model->common_public.suspend = action_suspend;
+ surf_timer_model->common_public.resume = action_resume;
+ surf_timer_model->common_public.is_suspended = action_is_suspended;
surf_timer_model->extension_public->set = set;
surf_timer_model->extension_public->get = get;
static int action_free(surf_action_t action)
{
if (action->model_type == (surf_model_t) surf_network_model)
- return surf_network_model->common_public->action_free(action);
+ return surf_network_model->common_public.action_free(action);
else if (action->model_type == (surf_model_t) surf_cpu_model)
- return surf_cpu_model->common_public->action_free(action);
+ return surf_cpu_model->common_public.action_free(action);
else if (action->model_type == (surf_model_t) surf_workstation_model)
return parallel_action_free(action);
else
static void action_use(surf_action_t action)
{
if (action->model_type == (surf_model_t) surf_network_model)
- surf_network_model->common_public->action_use(action);
+ surf_network_model->common_public.action_use(action);
else if (action->model_type == (surf_model_t) surf_cpu_model)
- surf_cpu_model->common_public->action_use(action);
+ surf_cpu_model->common_public.action_use(action);
else if (action->model_type == (surf_model_t) surf_workstation_model)
parallel_action_use(action);
else
static void action_cancel(surf_action_t action)
{
if (action->model_type == (surf_model_t) surf_network_model)
- surf_network_model->common_public->action_cancel(action);
+ surf_network_model->common_public.action_cancel(action);
else if (action->model_type == (surf_model_t) surf_cpu_model)
- surf_cpu_model->common_public->action_cancel(action);
+ surf_cpu_model->common_public.action_cancel(action);
else if (action->model_type == (surf_model_t) surf_workstation_model)
parallel_action_cancel(action);
else
return;
}
-static void action_recycle(surf_action_t action)
-{
- DIE_IMPOSSIBLE;
- return;
-}
-
static void action_change_state(surf_action_t action,
e_surf_action_state_t state)
{
if (action->model_type == (surf_model_t) surf_network_model)
- surf_network_model->common_public->action_change_state(action, state);
+ surf_network_model->common_public.action_change_state(action, state);
else if (action->model_type == (surf_model_t) surf_cpu_model)
- surf_cpu_model->common_public->action_change_state(action, state);
+ surf_cpu_model->common_public.action_change_state(action, state);
else if (action->model_type == (surf_model_t) surf_workstation_model)
surf_action_change_state(action, state);
else
static void action_suspend(surf_action_t action)
{
if (action->model_type == (surf_model_t) surf_network_model)
- surf_network_model->common_public->suspend(action);
+ surf_network_model->common_public.suspend(action);
else if (action->model_type == (surf_model_t) surf_cpu_model)
- surf_cpu_model->common_public->suspend(action);
+ surf_cpu_model->common_public.suspend(action);
else
DIE_IMPOSSIBLE;
}
static void action_resume(surf_action_t action)
{
if (action->model_type == (surf_model_t) surf_network_model)
- surf_network_model->common_public->resume(action);
+ surf_network_model->common_public.resume(action);
else if (action->model_type == (surf_model_t) surf_cpu_model)
- surf_cpu_model->common_public->resume(action);
+ surf_cpu_model->common_public.resume(action);
else
DIE_IMPOSSIBLE;
}
static int action_is_suspended(surf_action_t action)
{
if (action->model_type == (surf_model_t) surf_network_model)
- return surf_network_model->common_public->is_suspended(action);
+ return surf_network_model->common_public.is_suspended(action);
if (action->model_type == (surf_model_t) surf_cpu_model)
- return surf_cpu_model->common_public->is_suspended(action);
+ return surf_cpu_model->common_public.is_suspended(action);
DIE_IMPOSSIBLE;
}
static void action_set_max_duration(surf_action_t action, double duration)
{
if (action->model_type == (surf_model_t) surf_network_model)
- surf_network_model->common_public->set_max_duration(action, duration);
+ surf_network_model->common_public.set_max_duration(action, duration);
else if (action->model_type == (surf_model_t) surf_cpu_model)
- surf_cpu_model->common_public->set_max_duration(action, duration);
+ surf_cpu_model->common_public.set_max_duration(action, duration);
else
DIE_IMPOSSIBLE;
}
static void action_set_priority(surf_action_t action, double priority)
{
if (action->model_type == (surf_model_t) surf_network_model)
- surf_network_model->common_public->set_priority(action, priority);
+ surf_network_model->common_public.set_priority(action, priority);
else if (action->model_type == (surf_model_t) surf_cpu_model)
- surf_cpu_model->common_public->set_priority(action, priority);
+ surf_cpu_model->common_public.set_priority(action, priority);
else
DIE_IMPOSSIBLE;
}
static xbt_dict_t get_properties(void *workstation)
{
return surf_cpu_model->
- common_public->get_properties(((workstation_CLM03_t) workstation)->cpu);
+ common_public.get_properties(((workstation_CLM03_t) workstation)->cpu);
}
static surf_action_t execute_parallel_task(int workstation_nb,
static void finalize(void)
{
xbt_dict_free(&workstation_set);
- xbt_swag_free(surf_workstation_model->common_public->
- states.ready_action_set);
- xbt_swag_free(surf_workstation_model->common_public->
- states.running_action_set);
- xbt_swag_free(surf_workstation_model->common_public->
- states.failed_action_set);
- xbt_swag_free(surf_workstation_model->common_public->
- states.done_action_set);
-
- free(surf_workstation_model->common_public);
- free(surf_workstation_model->common_private);
+
+ surf_model_exit((surf_model_t)surf_workstation_model);
+
free(surf_workstation_model->extension_public);
free(surf_workstation_model);
static void surf_workstation_model_init_internal(void)
{
- s_surf_action_t action;
-
surf_workstation_model = xbt_new0(s_surf_workstation_model_t, 1);
- surf_workstation_model->common_private =
- xbt_new0(s_surf_model_private_t, 1);
- surf_workstation_model->common_public = xbt_new0(s_surf_model_public_t, 1);
+ surf_model_init((surf_model_t)surf_workstation_model);
/* surf_workstation_model->extension_private = xbt_new0(s_surf_workstation_model_extension_private_t,1); */
surf_workstation_model->extension_public =
xbt_new0(s_surf_workstation_model_extension_public_t, 1);
- surf_workstation_model->common_public->states.ready_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_workstation_model->common_public->states.running_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_workstation_model->common_public->states.failed_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_workstation_model->common_public->states.done_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
-
- surf_workstation_model->common_public->name_service = name_service;
- surf_workstation_model->common_public->get_resource_name =
+ surf_workstation_model->common_public.name_service = name_service;
+ surf_workstation_model->common_public.get_resource_name =
get_resource_name;
- surf_workstation_model->common_public->action_get_state =
+ surf_workstation_model->common_public.action_get_state =
surf_action_get_state;
- surf_workstation_model->common_public->action_get_start_time =
+ surf_workstation_model->common_public.action_get_start_time =
surf_action_get_start_time;
- surf_workstation_model->common_public->action_get_finish_time =
+ surf_workstation_model->common_public.action_get_finish_time =
surf_action_get_finish_time;
- surf_workstation_model->common_public->action_free = action_free;
- surf_workstation_model->common_public->action_use = action_use;
- surf_workstation_model->common_public->action_cancel = action_cancel;
- surf_workstation_model->common_public->action_recycle = action_recycle;
- surf_workstation_model->common_public->action_change_state =
+ surf_workstation_model->common_public.action_free = action_free;
+ surf_workstation_model->common_public.action_use = action_use;
+ surf_workstation_model->common_public.action_cancel = action_cancel;
+ surf_workstation_model->common_public.action_change_state =
action_change_state;
- surf_workstation_model->common_public->action_set_data =
+ surf_workstation_model->common_public.action_set_data =
surf_action_set_data;
- surf_workstation_model->common_public->name = "Workstation";
+ surf_workstation_model->common_public.name = "Workstation";
surf_workstation_model->common_private->resource_used = resource_used;
surf_workstation_model->common_private->share_resources = share_resources;
update_resource_state;
surf_workstation_model->common_private->finalize = finalize;
- surf_workstation_model->common_public->suspend = action_suspend;
- surf_workstation_model->common_public->resume = action_resume;
- surf_workstation_model->common_public->is_suspended = action_is_suspended;
- surf_workstation_model->common_public->set_max_duration =
+ surf_workstation_model->common_public.suspend = action_suspend;
+ surf_workstation_model->common_public.resume = action_resume;
+ surf_workstation_model->common_public.is_suspended = action_is_suspended;
+ surf_workstation_model->common_public.set_max_duration =
action_set_max_duration;
- surf_workstation_model->common_public->set_priority = action_set_priority;
+ surf_workstation_model->common_public.set_priority = action_set_priority;
surf_workstation_model->extension_public->execute = execute;
surf_workstation_model->extension_public->sleep = action_sleep;
get_available_speed;
/*manage the properties of the workstation */
- surf_workstation_model->common_public->get_properties = get_properties;
+ surf_workstation_model->common_public.get_properties = get_properties;
surf_workstation_model->extension_public->communicate = communicate;
surf_workstation_model->extension_public->execute_parallel_task =
return;
}
-static void action_recycle(surf_action_t action)
-{
- DIE_IMPOSSIBLE;
- return;
-}
-
/* action_change_state is inherited from the surf module */
/* action_set_data is inherited from the surf module */
surf_action_workstation_L07_t action = NULL;
xbt_swag_t running_actions =
- surf_workstation_model->common_public->states.running_action_set;
+ surf_workstation_model->common_public.states.running_action_set;
double min = generic_maxmin_share_resources(running_actions,
xbt_swag_offset(s_action,
variable),
surf_action_workstation_L07_t action = NULL;
surf_action_workstation_L07_t next_action = NULL;
xbt_swag_t running_actions =
- surf_workstation_model->common_public->states.running_action_set;
+ surf_workstation_model->common_public.states.running_action_set;
xbt_swag_foreach_safe(action, next_action, running_actions) {
deltap = delta;
if (parallel_task_link_set != NULL) {
xbt_dict_free(¶llel_task_link_set);
}
- xbt_swag_free(surf_workstation_model->common_public->
- states.ready_action_set);
- xbt_swag_free(surf_workstation_model->common_public->
- states.running_action_set);
- xbt_swag_free(surf_workstation_model->common_public->
- states.failed_action_set);
- xbt_swag_free(surf_workstation_model->common_public->
- states.done_action_set);
-
- free(surf_workstation_model->common_public);
- free(surf_workstation_model->common_private);
+
+ surf_model_exit((surf_model_t)surf_workstation_model);
+
free(surf_workstation_model->extension_public);
free(surf_workstation_model);
action->communication_amount = communication_amount;
action->latency = latency;
action->generic_action.state_set =
- surf_workstation_model->common_public->states.running_action_set;
+ surf_workstation_model->common_public.states.running_action_set;
xbt_swag_insert(action, action->generic_action.state_set);
action->rate = rate;
static void model_init_internal(void)
{
- s_surf_action_t action;
-
surf_workstation_model = xbt_new0(s_surf_workstation_model_t, 1);
- surf_workstation_model->common_private =
- xbt_new0(s_surf_model_private_t, 1);
- surf_workstation_model->common_public = xbt_new0(s_surf_model_public_t, 1);
+ surf_model_init((surf_model_t)surf_workstation_model);
surf_workstation_model->extension_public =
xbt_new0(s_surf_workstation_model_extension_public_t, 1);
- surf_workstation_model->common_public->states.ready_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_workstation_model->common_public->states.running_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_workstation_model->common_public->states.failed_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
- surf_workstation_model->common_public->states.done_action_set =
- xbt_swag_new(xbt_swag_offset(action, state_hookup));
-
- surf_workstation_model->common_public->name_service = name_service;
- surf_workstation_model->common_public->get_resource_name =
+ surf_workstation_model->common_public.name_service = name_service;
+ surf_workstation_model->common_public.get_resource_name =
get_resource_name;
- surf_workstation_model->common_public->action_get_state =
+ surf_workstation_model->common_public.action_get_state =
surf_action_get_state;
- surf_workstation_model->common_public->action_get_start_time =
+ surf_workstation_model->common_public.action_get_start_time =
surf_action_get_start_time;
- surf_workstation_model->common_public->action_get_finish_time =
+ surf_workstation_model->common_public.action_get_finish_time =
surf_action_get_finish_time;
- surf_workstation_model->common_public->action_use = action_use;
- surf_workstation_model->common_public->action_free = action_free;
- surf_workstation_model->common_public->action_cancel = action_cancel;
- surf_workstation_model->common_public->action_recycle = action_recycle;
- surf_workstation_model->common_public->action_change_state =
+ surf_workstation_model->common_public.action_use = action_use;
+ surf_workstation_model->common_public.action_free = action_free;
+ surf_workstation_model->common_public.action_cancel = action_cancel;
+ surf_workstation_model->common_public.action_change_state =
surf_action_change_state;
- surf_workstation_model->common_public->action_set_data =
+ surf_workstation_model->common_public.action_set_data =
surf_action_set_data;
- surf_workstation_model->common_public->suspend = action_suspend;
- surf_workstation_model->common_public->resume = action_resume;
- surf_workstation_model->common_public->is_suspended = action_is_suspended;
- surf_workstation_model->common_public->set_max_duration =
+ surf_workstation_model->common_public.suspend = action_suspend;
+ surf_workstation_model->common_public.resume = action_resume;
+ surf_workstation_model->common_public.is_suspended = action_is_suspended;
+ surf_workstation_model->common_public.set_max_duration =
action_set_max_duration;
- surf_workstation_model->common_public->set_priority = action_set_priority;
- surf_workstation_model->common_public->name = "Workstation ptask_L07";
+ surf_workstation_model->common_public.set_priority = action_set_priority;
+ surf_workstation_model->common_public.name = "Workstation ptask_L07";
surf_workstation_model->common_private->resource_used = resource_used;
surf_workstation_model->common_private->share_resources = share_resources;
get_link_latency;
surf_workstation_model->extension_public->link_shared = link_shared;
- surf_workstation_model->common_public->get_properties = get_properties;
+ surf_workstation_model->common_public.get_properties = get_properties;
workstation_set = xbt_dict_new();
link_set = xbt_dict_new();
