into surf_model_resource_by_name(model)
(less redirections, less function to write when defining a model)
* Unify the types of models in a uniq s_surf_model_t (using an union)
+ * Embeed every fields of common_public directly into s_surf_model_t
XBT:
* Add xbt_set_get_by_name_or_null() [Silas De Munck]
--leave-preprocessor-space --no-space-after-function-call-names \
`$(MAKE) dist-files | grep '\.[ch]$$'|grep -v '/_' |grep -v '_unit.c'\
| grep -v src/xbt/graphxml.c | grep -v datadesc_structs.c \
- `
+ | grep -v simgrid_dtd.[ch]`
sync-gforge:
chmod g+rw -R doc/
/* struct for recovering results */
GRAS_DEFINE_TYPE(s_result, struct s_result {
- int linepos; int rowpos;
- xbt_matrix_t C GRAS_ANNOTE(subtype, double);
- });
+ int linepos;
+ int rowpos; xbt_matrix_t C GRAS_ANNOTE(subtype, double);});
typedef struct s_result result_t;
xbt_peer_t line[NEIGHBOR_COUNT];
xbt_peer_t row[NEIGHBOR_COUNT];
xbt_matrix_t A GRAS_ANNOTE(subtype, double);
- xbt_matrix_t B GRAS_ANNOTE(subtype, double);
- });
+ xbt_matrix_t B GRAS_ANNOTE(subtype, double);});
typedef struct s_pmm_assignment s_pmm_assignment_t;
/** \brief Prototype of type callbacks selecting a type. */
typedef
+
+
+
gras_datadesc_type_t(*gras_datadesc_selector_t) (gras_datadesc_type_t
typedesc,
res->peer_port = ((gras_trp_procdata_t)
gras_libdata_by_name_from_remote("gras_trp",
- sockdata->
- to_process))->myport;
+ sockdata->to_process))->
+ myport;
sockdata->to_socket = active_socket;
/*update the peer to_socket variable */
active_socket_data->to_socket = res;
XBT_PUBLIC(void) lmm_set_default_protocol_function(double (*func_f)
+
+
+
(lmm_variable_t var,
double x),
double (*func_fp)
+
+
+
(lmm_variable_t var,
double x),
double (*func_fpi)
+
+
+
(lmm_variable_t var,
double x));
* These functions are implemented by all models.
*/
typedef struct surf_model_public {
- s_surf_action_state_t states;
- /**< Any living action on this model */
- const char *(*get_resource_name) (void *resource_id);
- /**< Return the name of a resource */
-
- e_surf_action_state_t(*action_get_state) (surf_action_t action);
- /**< Return the state of an action */
- double (*action_get_start_time) (surf_action_t action);
- /**< Return the start time of an action */
- double (*action_get_finish_time) (surf_action_t action);
- /**< Return the finish time of an action */
- void (*action_use) (surf_action_t action);
- /**< Set an action used */
- int (*action_free) (surf_action_t action);
- /**< Free an action */
- void (*action_cancel) (surf_action_t action);
- /**< Cancel a running action */
- void (*action_recycle) (surf_action_t action);
- /**< Recycle an action */
- void (*action_change_state) (surf_action_t action,
- /**< Change an action state*/
- e_surf_action_state_t state);
- void (*action_set_data) (surf_action_t action, void *data);
- /**< Set the user data of an action */
- void (*suspend) (surf_action_t action);
- /**< Suspend an action */
- void (*resume) (surf_action_t action);
- /**< Resume a suspended action */
- int (*is_suspended) (surf_action_t action);
- /**< Return whether an action is suspended */
- void (*set_max_duration) (surf_action_t action, double duration);
- /**< Set the max duration of an action*/
- void (*set_priority) (surf_action_t action, double priority);
- /**< Set the priority of an action */
- xbt_dict_t(*get_properties) (void *resource_id);
- /**< Return the properties dictionary */
- const char *name;
- /**< Name of this model */
- xbt_dict_t resource_set;
} s_surf_model_public_t, *surf_model_public_t;
/** \brief Private data available on all models
typedef struct surf_timer_model_extension_public {
void (*set) (double date, void *function, void *arg);
int (*get) (void **function, void **arg);
- } s_surf_timer_model_extension_public_t;
+ } s_surf_model_extension_timer_t;
- /* Cpu model */
+ /* Cpu model */
- /** \brief CPU state
- * \ingroup SURF_models
- */
+ /** \brief CPU state
+ * \ingroup SURF_models
+ */
typedef enum {
SURF_CPU_ON = 1, /**< Up & ready */
SURF_CPU_OFF = 0 /**< Down & broken */
} e_surf_cpu_state_t;
- /** \brief CPU model extension public
- * \ingroup SURF_models
- *
- * Public functions specific to the CPU model.
- */
+ /** \brief CPU model extension public
+ * \ingroup SURF_models
+ *
+ * Public functions specific to the CPU model.
+ */
typedef struct surf_cpu_model_extension_public {
surf_action_t(*execute) (void *cpu, double size);
surf_action_t(*sleep) (void *cpu, double duration);
e_surf_cpu_state_t(*get_state) (void *cpu);
double (*get_speed) (void *cpu, double load);
double (*get_available_speed) (void *cpu);
- } s_surf_cpu_model_extension_public_t;
+ } s_surf_model_extension_cpu_t;
- /* Network model */
+ /* Network model */
- /** \brief Network model extension public
- * \ingroup SURF_models
- *
- * Public functions specific to the network model
- */
+ /** \brief Network model extension public
+ * \ingroup SURF_models
+ *
+ * Public functions specific to the network model
+ */
typedef struct surf_network_model_extension_public {
surf_action_t(*communicate) (void *src, void *dst, double size,
double max_rate);
double (*get_link_bandwidth) (const void *link);
double (*get_link_latency) (const void *link);
int (*link_shared) (const void *link);
- } s_surf_network_model_extension_public_t;
+ } s_surf_model_extension_network_t;
- /** \brief Workstation model extension public
- * \ingroup SURF_models
- *
- * Public functions specific to the workstation model.
- */
+ /** \brief Workstation model extension public
+ * \ingroup SURF_models
+ *
+ * Public functions specific to the workstation model.
+ */
typedef struct surf_workstation_model_extension_public {
surf_action_t(*execute) (void *workstation, double size); /**< Execute a computation amount on a workstation
and create the corresponding action */
double (*get_link_bandwidth) (const void *link); /**< Return the current bandwidth of a network link */
double (*get_link_latency) (const void *link); /**< Return the current latency of a network link */
int (*link_shared) (const void *link);
- } s_surf_workstation_model_extension_public_t;
+ } s_surf_model_extension_workstation_t;
/** \brief Model datatype
* \ingroup SURF_models
* 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;
+ const char *name;/**< Name of this model */
+ s_surf_action_state_t states; /**< Any living action on this model */
+ const char *(*get_resource_name) (void *resource_id);/**< Return the name of a resource */
+
+ e_surf_action_state_t(*action_get_state) (surf_action_t action);/**< Return the state of an action */
+ double (*action_get_start_time) (surf_action_t action);/**< Return the start time of an action */
+ double (*action_get_finish_time) (surf_action_t action);/**< Return the finish time of an action */
+ void (*action_use) (surf_action_t action);/**< Set an action used */
+ int (*action_free) (surf_action_t action);/**< Free an action */
+ void (*action_cancel) (surf_action_t action);/**< Cancel a running action */
+ void (*action_recycle) (surf_action_t action);/**< Recycle an action */
+ void (*action_change_state) (surf_action_t action,
+ e_surf_action_state_t state);
+ /**< Change an action state*/
+ void (*action_set_data) (surf_action_t action, void *data);/**< Set the user data of an action */
+ void (*suspend) (surf_action_t action);/**< Suspend an action */
+ void (*resume) (surf_action_t action);/**< Resume a suspended action */
+ int (*is_suspended) (surf_action_t action);/**< Return whether an action is suspended */
+ void (*set_max_duration) (surf_action_t action, double duration);/**< Set the max duration of an action*/
+ void (*set_priority) (surf_action_t action, double priority);/**< Set the priority of an action */
+ xbt_dict_t(*get_properties) (void *resource_id);/**< Return the properties dictionary */
+ xbt_dict_t resource_set;
+
+
+
+ surf_model_private_t model_private;
+
+
+
union extension {
- s_surf_timer_model_extension_public_t timer;
- s_surf_cpu_model_extension_public_t cpu;
- s_surf_network_model_extension_public_t network;
- s_surf_workstation_model_extension_public_t workstation;
+ s_surf_model_extension_timer_t timer;
+ s_surf_model_extension_cpu_t cpu;
+ s_surf_model_extension_network_t network;
+ s_surf_model_extension_workstation_t workstation;
} extension;
} s_surf_model_t;
void surf_model_init(surf_model_t model);
void *surf_model_resource_by_name(surf_model_t model, const char *name);
-#define surf_model_resource_set(model) (model)->common_public.resource_set
+#define surf_model_resource_set(model) (model)->resource_set
void surf_model_exit(surf_model_t model);
typedef struct surf_resource {
/* Transfer */
/* create SIMIX action to the communication */
t_simdata->comm =
- SIMIX_action_communicate(t_simdata->sender->simdata->m_host->simdata->
- smx_host,
+ SIMIX_action_communicate(t_simdata->sender->simdata->m_host->
+ simdata->smx_host,
process->simdata->m_host->simdata->smx_host,
t->name, t_simdata->message_size,
t_simdata->rate);
/* let's see which tasks are done */
xbt_dynar_foreach(model_list, iter, model) {
- while ((action =
- xbt_swag_extract(model->common_public.states.
- done_action_set))) {
+ while ((action = xbt_swag_extract(model->states.done_action_set))) {
task = action->data;
INFO1("Task '%s' done", SD_task_get_name(task));
DEBUG0("Calling __SD_task_just_done");
}
/* let's see which tasks have just failed */
- while ((action =
- xbt_swag_extract(model->common_public.states.
- failed_action_set))) {
+ while ((action = xbt_swag_extract(model->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->action_free(action);
task->surf_action = NULL;
if (!xbt_dynar_member(changed_tasks, &task))
{
SD_CHECK_INIT_DONE();
xbt_assert0(link != NULL, "Invalid parameter");
- return surf_workstation_model->extension.workstation.get_link_name(link->
- surf_link);
+ return surf_workstation_model->extension.workstation.
+ get_link_name(link->surf_link);
}
/**
{
SD_CHECK_INIT_DONE();
xbt_assert0(link != NULL, "Invalid parameter");
- return surf_workstation_model->extension.
- workstation.get_link_bandwidth(link->surf_link);
+ return surf_workstation_model->extension.workstation.
+ get_link_bandwidth(link->surf_link);
}
/**
SD_CHECK_INIT_DONE();
xbt_assert0((link != NULL), "Invalid parameters");
- return (surf_workstation_model->common_public.
- get_properties(link->surf_link));
+ return (surf_workstation_model->get_properties(link->surf_link));
}
{
SD_CHECK_INIT_DONE();
xbt_assert0(link != NULL, "Invalid parameter");
- return surf_workstation_model->extension.workstation.get_link_latency(link->
- surf_link);
+ return surf_workstation_model->extension.workstation.
+ get_link_latency(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_action);
+ surf_workstation_model->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_action);
+ surf_workstation_model->action_get_finish_time(task->surf_action);
task->remains = 0;
break;
case SD_FAILED:
__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->action_cancel(task->surf_action);
else
__SD_task_set_state(task, SD_NOT_SCHEDULED);
task->remains = task->amount;
task->surf_action = NULL;
if ((task->workstation_nb == 1) && (task->communication_amount[0] == 0.0)) {
task->surf_action =
- surf_workstation_model->extension.
- workstation.execute(surf_workstations[0], task->computation_amount[0]);
+ surf_workstation_model->extension.workstation.
+ execute(surf_workstations[0], task->computation_amount[0]);
} else if ((task->workstation_nb == 1)
&& (task->computation_amount[0] == 0.0)) {
task->surf_action =
- surf_workstation_model->extension.
- workstation.communicate(surf_workstations[0], surf_workstations[0],
- task->communication_amount[0], task->rate);
+ surf_workstation_model->extension.workstation.
+ communicate(surf_workstations[0], surf_workstations[0],
+ task->communication_amount[0], task->rate);
} else if ((task->workstation_nb == 2)
&& (task->computation_amount[0] == 0.0)
&& (task->computation_amount[1] == 0.0)) {
}
if (nb == 1) {
task->surf_action =
- surf_workstation_model->extension.
- workstation.communicate(surf_workstations[0], surf_workstations[1],
- value, task->rate);
+ surf_workstation_model->extension.workstation.
+ communicate(surf_workstations[0], surf_workstations[1], value,
+ task->rate);
}
}
if (!task->surf_action) {
sizeof(double) * task->workstation_nb * task->workstation_nb);
task->surf_action =
- surf_workstation_model->extension.
- workstation.execute_parallel_task(task->workstation_nb,
- surf_workstations, computation_amount,
- communication_amount, task->amount,
- task->rate);
+ surf_workstation_model->extension.workstation.
+ execute_parallel_task(task->workstation_nb, surf_workstations,
+ computation_amount, communication_amount,
+ task->amount, task->rate);
} else {
xbt_free(surf_workstations);
}
- surf_workstation_model->common_public.action_set_data(task->surf_action,
- task);
+ surf_workstation_model->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->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->
- surf_action);
+ return surf_workstation_model->action_get_start_time(task->surf_action);
else
return task->start_time;
}
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.
- action_get_finish_time(task->surf_action);
+ return surf_workstation_model->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->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.
- get_resource_name(workstation->surf_workstation);
+ return surf_workstation_model->get_resource_name(workstation->
+ surf_workstation);
}
/**
SD_CHECK_INIT_DONE();
xbt_assert0((workstation != NULL), "Invalid parameters");
- return (surf_workstation_model->common_public.
- get_properties(workstation->surf_workstation));
+ return (surf_workstation_model->get_properties
+ (workstation->surf_workstation));
}
for (i = 0; i < route_size; i++) {
link_name =
- surf_workstation_model->extension.
- workstation.get_link_name(surf_route[i]);
+ surf_workstation_model->extension.workstation.
+ get_link_name(surf_route[i]);
sd_global->recyclable_route[i] =
xbt_dict_get(sd_global->links, link_name);
}
int SD_route_get_size(SD_workstation_t src, SD_workstation_t dst)
{
SD_CHECK_INIT_DONE();
- return surf_workstation_model->extension.workstation.get_route_size(src->
- surf_workstation,
- dst->
- surf_workstation);
+ return surf_workstation_model->extension.workstation.
+ get_route_size(src->surf_workstation, dst->surf_workstation);
}
/**
{
SD_CHECK_INIT_DONE();
xbt_assert0(workstation != NULL, "Invalid parameter");
- return surf_workstation_model->extension.workstation.get_speed(workstation->
- surf_workstation,
- 1.0);
+ return surf_workstation_model->extension.workstation.
+ get_speed(workstation->surf_workstation, 1.0);
}
/**
{
SD_CHECK_INIT_DONE();
xbt_assert0(workstation != NULL, "Invalid parameter");
- return surf_workstation_model->extension.workstation.
- get_available_speed(workstation->surf_workstation);
+ return surf_workstation_model->extension.
+ workstation.get_available_speed(workstation->surf_workstation);
}
/**
}
/* Returns whether a task can start now on a workstation.
- *//*
- int __SD_workstation_can_start(SD_workstation_t workstation, SD_task_t task) {
- SD_CHECK_INIT_DONE();
- xbt_assert0(workstation != NULL && task != NULL, "Invalid parameter");
-
- return !__SD_workstation_is_busy(workstation) &&
- (xbt_fifo_size(workstation->task_fifo) == 0) || xbt_fifo_get_first_item(workstation->task_fifo) == task);
- }
- */
+ *//*
+ int __SD_workstation_can_start(SD_workstation_t workstation, SD_task_t task) {
+ SD_CHECK_INIT_DONE();
+ xbt_assert0(workstation != NULL && task != NULL, "Invalid parameter");
+
+ return !__SD_workstation_is_busy(workstation) &&
+ (xbt_fifo_size(workstation->task_fifo) == 0) || xbt_fifo_get_first_item(workstation->task_fifo) == task);
+ }
+ */
/* Returns whether a workstation is busy. A workstation is busy is it is
* in sequential mode and a task is running on it or the fifo is not empty.
simdata->surf_action =
surf_workstation_model->extension.workstation.
communicate(sender->simdata->host, receiver->simdata->host, size, rate);
- surf_workstation_model->common_public.action_set_data(simdata->surf_action,
- act);
+ surf_workstation_model->action_set_data(simdata->surf_action, act);
DEBUG1("Create communicate action %p", act);
return act;
surf_workstation_model->extension.workstation.execute(host->simdata->host,
amount);
- surf_workstation_model->common_public.action_set_data(simdata->surf_action,
- act);
+ surf_workstation_model->action_set_data(simdata->surf_action, act);
DEBUG1("Create execute action %p", act);
return act;
surf_workstation_model->extension.workstation.sleep(host->simdata->host,
duration);
- surf_workstation_model->common_public.action_set_data(simdata->surf_action,
- act);
+ surf_workstation_model->action_set_data(simdata->surf_action, act);
DEBUG1("Create sleep action %p", act);
return act;
DEBUG1("Cancel action %p", action);
if (action->simdata->surf_action) {
- surf_workstation_model->common_public.action_cancel(action->simdata->
- surf_action);
+ surf_workstation_model->action_cancel(action->simdata->surf_action);
}
return;
}
xbt_assert0((action != NULL)
&& (action->simdata != NULL), "Invalid parameter");
- surf_workstation_model->common_public.set_priority(action->simdata->
- surf_action, priority);
+ surf_workstation_model->set_priority(action->simdata->surf_action,
+ priority);
return;
}
xbt_fifo_free(action->cond_list);
if (action->simdata->surf_action)
- action->simdata->surf_action->model_type->
- common_public.action_free(action->simdata->surf_action);
+ action->simdata->surf_action->model_type->action_free(action->
+ simdata->surf_action);
xbt_free(action->simdata);
xbt_free(action);
computation_amount,
communication_amount, amount, rate);
- surf_workstation_model->common_public.action_set_data(simdata->surf_action,
- act);
+ surf_workstation_model->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->
- simdata->
- surf_action);
+ return surf_workstation_model->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->states.failed_action_set)
+ || xbt_swag_size(model->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.
- states.failed_action_set))) {
+ while ((action = xbt_swag_extract(model->states.failed_action_set))) {
smx_action = action->data;
if (smx_action) {
xbt_fifo_unshift(actions_failed, smx_action);
}
}
- while ((action =
- xbt_swag_extract(model->common_public.
- states.done_action_set))) {
+ while ((action = xbt_swag_extract(model->states.done_action_set))) {
smx_action = action->data;
if (smx_action) {
xbt_fifo_unshift(actions_done, smx_action);
{
xbt_assert0((host != NULL), "Invalid parameters");
- return (surf_workstation_model->common_public.
- get_properties(host->simdata->host));
+ return (surf_workstation_model->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->
- simdata->surf_action);
+ surf_workstation_model->suspend(act->simdata->surf_action);
}
} else {
simdata->suspended = 1;
cond = SIMIX_cond_init();
dummy = SIMIX_action_execute(SIMIX_process_get_host(process), name, 0);
- surf_workstation_model->common_public.suspend(dummy->simdata->
- surf_action);
+ surf_workstation_model->suspend(dummy->simdata->surf_action);
SIMIX_register_action_to_condition(dummy, cond);
__SIMIX_cond_wait(cond);
SIMIX_unregister_action_to_condition(dummy, 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_action);
+ surf_workstation_model->resume(act->simdata->surf_action);
}
SIMIX_cond_signal(c);
return;
static double share_resources(double now)
{
s_surf_action_cpu_Cas01_t action;
- return generic_maxmin_share_resources(surf_cpu_model->common_public.states.
- running_action_set,
+ return generic_maxmin_share_resources(surf_cpu_model->
+ 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;
+ xbt_swag_t running_actions = surf_cpu_model->states.running_action_set;
/* FIXME: UNUSED
xbt_swag_t failed_actions =
- surf_cpu_model->common_public.states.failed_action_set;
+ surf_cpu_model->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->states.running_action_set;
else
action->generic_action.state_set =
- surf_cpu_model->common_public.states.failed_action_set;
+ surf_cpu_model->states.failed_action_set;
xbt_swag_insert(action, action->generic_action.state_set);
running_action_set_that_does_not_need_being_checked =
xbt_swag_new(xbt_swag_offset(action, state_hookup));
- 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_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_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;
- surf_cpu_model->common_private->update_actions_state = update_actions_state;
- surf_cpu_model->common_private->update_resource_state =
+ surf_cpu_model->get_resource_name = get_resource_name;
+ surf_cpu_model->action_get_state = surf_action_get_state;
+ surf_cpu_model->action_get_start_time = surf_action_get_start_time;
+ surf_cpu_model->action_get_finish_time = surf_action_get_finish_time;
+ surf_cpu_model->action_free = action_free;
+ surf_cpu_model->action_use = action_use;
+ surf_cpu_model->action_cancel = action_cancel;
+ surf_cpu_model->action_change_state = action_change_state;
+ surf_cpu_model->action_set_data = surf_action_set_data;
+ surf_cpu_model->name = "CPU";
+
+ surf_cpu_model->model_private->resource_used = resource_used;
+ surf_cpu_model->model_private->share_resources = share_resources;
+ surf_cpu_model->model_private->update_actions_state = update_actions_state;
+ surf_cpu_model->model_private->update_resource_state =
update_resource_state;
- surf_cpu_model->common_private->finalize = finalize;
+ surf_cpu_model->model_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->suspend = action_suspend;
+ surf_cpu_model->resume = action_resume;
+ surf_cpu_model->is_suspended = action_is_suspended;
+ surf_cpu_model->set_max_duration = action_set_max_duration;
+ surf_cpu_model->set_priority = action_set_priority;
surf_cpu_model->extension.cpu.execute = execute;
surf_cpu_model->extension.cpu.sleep = action_sleep;
surf_cpu_model->extension.cpu.get_speed = get_speed;
surf_cpu_model->extension.cpu.get_available_speed = get_available_speed;
/*manage the properties of the cpu */
- surf_cpu_model->common_public.get_properties = get_properties;
+ surf_cpu_model->get_properties = get_properties;
if (!cpu_maxmin_system)
cpu_maxmin_system = lmm_system_new();
void lmm_set_default_protocol_function(double (*func_f)
+
+
+
(lmm_variable_t var, double x),
double (*func_fp) (lmm_variable_t var,
s_surf_action_t action;
- model->common_private = xbt_new0(s_surf_model_private_t, 1);
+ model->model_private = xbt_new0(s_surf_model_private_t, 1);
- model->common_public.states.ready_action_set =
+ model->states.ready_action_set =
xbt_swag_new(xbt_swag_offset(action, state_hookup));
- model->common_public.states.running_action_set =
+ model->states.running_action_set =
xbt_swag_new(xbt_swag_offset(action, state_hookup));
- model->common_public.states.failed_action_set =
+ model->states.failed_action_set =
xbt_swag_new(xbt_swag_offset(action, state_hookup));
- model->common_public.states.done_action_set =
+ model->states.done_action_set =
xbt_swag_new(xbt_swag_offset(action, state_hookup));
- model->common_public.resource_set = xbt_dict_new();
+ model->resource_set = xbt_dict_new();
- 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;
+ model->action_free = int_die_impossible_paction;
+ model->action_cancel = void_die_impossible_paction;
+ model->action_recycle = void_die_impossible_paction;
}
void *surf_model_resource_by_name(surf_model_t model, const char *name)
{
- return xbt_dict_get_or_null(model->common_public.resource_set, name);
+ return xbt_dict_get_or_null(model->resource_set, name);
}
/** @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);
- xbt_dict_free(&model->common_public.resource_set);
- free(model->common_private);
+ xbt_swag_free(model->states.ready_action_set);
+ xbt_swag_free(model->states.running_action_set);
+ xbt_swag_free(model->states.failed_action_set);
+ xbt_swag_free(model->states.done_action_set);
+ xbt_dict_free(&model->resource_set);
+ free(model->model_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;
+ xbt_swag_t running_actions = surf_network_model->states.running_action_set;
double min;
min = generic_maxmin_share_resources(running_actions,
double deltap = 0.0;
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;
+ xbt_swag_t running_actions = surf_network_model->states.running_action_set;
/*
xbt_swag_t failed_actions =
- surf_network_model->common_public.states.failed_action_set;
+ surf_network_model->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->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->states.failed_action_set;
break;
}
surf_model_init(surf_network_model);
- 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_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 = 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_private->resource_used = resource_used;
- surf_network_model->common_private->share_resources = share_resources;
- surf_network_model->common_private->update_actions_state =
+ surf_network_model->get_resource_name = get_resource_name;
+ surf_network_model->action_get_state = surf_action_get_state;
+ surf_network_model->action_get_start_time = surf_action_get_start_time;
+ surf_network_model->action_get_finish_time = surf_action_get_finish_time;
+ surf_network_model->action_free = action_free;
+ surf_network_model->action_use = action_use;
+ surf_network_model->action_cancel = action_cancel;
+ surf_network_model->action_recycle = action_recycle;
+ surf_network_model->action_change_state = action_change_state;
+ surf_network_model->action_set_data = surf_action_set_data;
+ surf_network_model->name = "network";
+
+ surf_network_model->model_private->resource_used = resource_used;
+ surf_network_model->model_private->share_resources = share_resources;
+ surf_network_model->model_private->update_actions_state =
update_actions_state;
- surf_network_model->common_private->update_resource_state =
+ surf_network_model->model_private->update_resource_state =
update_resource_state;
- surf_network_model->common_private->finalize = finalize;
+ surf_network_model->model_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->suspend = action_suspend;
+ surf_network_model->resume = action_resume;
+ surf_network_model->is_suspended = action_is_suspended;
+ surf_cpu_model->set_max_duration = action_set_max_duration;
surf_network_model->extension.network.communicate = communicate;
surf_network_model->extension.network.get_route = get_route;
surf_network_model->extension.network.get_link_latency = get_link_latency;
surf_network_model->extension.network.link_shared = link_shared;
- surf_network_model->common_public.get_properties = get_properties;
+ surf_network_model->get_properties = get_properties;
link_set = xbt_dict_new();
static double share_resources(double now)
{
surf_action_network_Constant_t action = NULL;
- xbt_swag_t running_actions =
- surf_network_model->common_public.states.running_action_set;
+ xbt_swag_t running_actions = surf_network_model->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;
+ xbt_swag_t running_actions = surf_network_model->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->states.done_action_set;
else
action->generic_action.state_set =
- surf_network_model->common_public.states.running_action_set;
+ surf_network_model->states.running_action_set;
xbt_swag_insert(action, action->generic_action.state_set);
surf_model_init(surf_network_model);
- 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_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 = 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_private->resource_used = resource_used;
- surf_network_model->common_private->share_resources = share_resources;
- surf_network_model->common_private->update_actions_state =
+ surf_network_model->get_resource_name = get_resource_name;
+ surf_network_model->action_get_state = surf_action_get_state;
+ surf_network_model->action_get_start_time = surf_action_get_start_time;
+ surf_network_model->action_get_finish_time = surf_action_get_finish_time;
+ surf_network_model->action_free = action_free;
+ surf_network_model->action_use = action_use;
+ surf_network_model->action_cancel = action_cancel;
+ surf_network_model->action_recycle = action_recycle;
+ surf_network_model->action_change_state = action_change_state;
+ surf_network_model->action_set_data = surf_action_set_data;
+ surf_network_model->name = "network";
+
+ surf_network_model->model_private->resource_used = resource_used;
+ surf_network_model->model_private->share_resources = share_resources;
+ surf_network_model->model_private->update_actions_state =
update_actions_state;
- surf_network_model->common_private->update_resource_state =
+ surf_network_model->model_private->update_resource_state =
update_resource_state;
- surf_network_model->common_private->finalize = finalize;
+ surf_network_model->model_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->suspend = action_suspend;
+ surf_network_model->resume = action_resume;
+ surf_network_model->is_suspended = action_is_suspended;
+ surf_cpu_model->set_max_duration = action_set_max_duration;
surf_network_model->extension.network.communicate = communicate;
surf_network_model->extension.network.get_route = get_route;
surf_network_model->extension.network.get_link_latency = get_link_latency;
surf_network_model->extension.network.link_shared = link_shared;
- surf_network_model->common_public.get_properties = get_properties;
+ surf_network_model->get_properties = get_properties;
if (!random_latency)
random_latency = random_new(RAND, 100, 0.0, 1.0, .125, .034);
surf_model_exit(surf_network_model);
- free(surf_network_model->extension_public);
-
free(surf_network_model);
surf_network_model = NULL;
surf_model_init(surf_network_model);
- surf_network_model->extension_public =
- xbt_new0(s_surf_network_model_extension_public_t, 1);
-
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_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;
- surf_network_model->common_private->update_actions_state =
+ surf_network_model->model_private->resource_used = resource_used;
+ surf_network_model->model_private->share_resources = share_resources;
+ surf_network_model->model_private->update_actions_state =
update_actions_state;
- surf_network_model->common_private->update_resource_state =
+ surf_network_model->model_private->update_resource_state =
update_resource_state;
- surf_network_model->common_private->finalize = finalize;
+ surf_network_model->model_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->extension_public->communicate = communicate;
+ surf_network_model->extension.network.communicate = communicate;
/*for the props of the link */
surf_network_model->common_public.get_properties = get_properties;
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);
+ surf_action_state_t action_state = &(action->model_type->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->action_cancel(*action);
free(*action);
*action = NULL;
}
void surf_action_change_state(surf_action_t action,
e_surf_action_state_t state)
{
- surf_action_state_t action_state =
- &(action->model_type->common_public.states);
+ surf_action_state_t action_state = &(action->model_type->states);
XBT_IN2("(%p,%s)", action, surf_action_state_names[state]);
xbt_swag_remove(action, action->state_set);
surf_config_finalize();
xbt_dynar_foreach(model_list, iter, model) {
- model->common_private->finalize();
+ model->model_private->finalize();
}
if (maxmin_system) {
while ((event =
tmgr_history_get_next_event_leq(history, next_event_date,
&value, (void **) &resource))) {
- resource->model->common_private->update_resource_state(resource,
- event, value,
- NOW);
+ resource->model->model_private->update_resource_state(resource,
+ event, value,
+ NOW);
}
}
xbt_dynar_foreach(model_list, iter, model) {
- model->common_private->update_actions_state(NOW, 0.0);
+ model->model_private->update_actions_state(NOW, 0.0);
}
}
DEBUG0("Looking for next action end");
xbt_dynar_foreach(model_list, iter, model) {
- DEBUG1("Running for Resource [%s]", model->common_public.name);
- model_next_action_end = model->common_private->share_resources(NOW);
+ DEBUG1("Running for Resource [%s]", model->name);
+ model_next_action_end = model->model_private->share_resources(NOW);
DEBUG2("Resource [%s] : next action end = %f",
- model->common_public.name, model_next_action_end);
+ model->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;
while ((event =
tmgr_history_get_next_event_leq(history, next_event_date,
&value, (void **) &resource))) {
- if (resource->model->common_private->resource_used(resource)) {
+ if (resource->model->model_private->resource_used(resource)) {
min = next_event_date - NOW;
DEBUG1
("This event will modify model state. Next event set to %f", min);
}
/* update state of model_obj according to new value. Does not touch lmm.
It will be modified if needed when updating actions */
- resource->model->common_private->update_resource_state(resource,
- event, value,
- NOW + min);
+ resource->model->model_private->update_resource_state(resource,
+ event, value,
+ NOW + min);
}
}
NOW = NOW + min;
xbt_dynar_foreach(model_list, iter, model) {
- model->common_private->update_actions_state(NOW, min);
+ model->model_private->update_actions_state(NOW, min);
}
return min;
surf_model_init(surf_timer_model);
- 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;
- surf_timer_model->common_private->update_actions_state =
+ surf_timer_model->get_resource_name = get_resource_name;
+ surf_timer_model->action_get_state = surf_action_get_state;
+ surf_timer_model->action_change_state = action_change_state;
+ surf_timer_model->action_set_data = surf_action_set_data;
+ surf_timer_model->name = "TIMER";
+
+ surf_timer_model->model_private->resource_used = resource_used;
+ surf_timer_model->model_private->share_resources = share_resources;
+ surf_timer_model->model_private->update_actions_state =
update_actions_state;
- surf_timer_model->common_private->update_resource_state =
+ surf_timer_model->model_private->update_resource_state =
update_resource_state;
- surf_timer_model->common_private->finalize = finalize;
+ surf_timer_model->model_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->suspend = action_suspend;
+ surf_timer_model->resume = action_resume;
+ surf_timer_model->is_suspended = action_is_suspended;
surf_timer_model->extension.timer.set = set;
surf_timer_model->extension.timer.get = get;
static int action_free(surf_action_t action)
{
if (action->model_type == surf_network_model)
- return surf_network_model->common_public.action_free(action);
+ return surf_network_model->action_free(action);
else if (action->model_type == surf_cpu_model)
- return surf_cpu_model->common_public.action_free(action);
+ return surf_cpu_model->action_free(action);
else if (action->model_type == surf_workstation_model)
return parallel_action_free(action);
else
static void action_use(surf_action_t action)
{
if (action->model_type == surf_network_model)
- surf_network_model->common_public.action_use(action);
+ surf_network_model->action_use(action);
else if (action->model_type == surf_cpu_model)
- surf_cpu_model->common_public.action_use(action);
+ surf_cpu_model->action_use(action);
else if (action->model_type == surf_workstation_model)
parallel_action_use(action);
else
static void action_cancel(surf_action_t action)
{
if (action->model_type == surf_network_model)
- surf_network_model->common_public.action_cancel(action);
+ surf_network_model->action_cancel(action);
else if (action->model_type == surf_cpu_model)
- surf_cpu_model->common_public.action_cancel(action);
+ surf_cpu_model->action_cancel(action);
else if (action->model_type == surf_workstation_model)
parallel_action_cancel(action);
else
e_surf_action_state_t state)
{
if (action->model_type == surf_network_model)
- surf_network_model->common_public.action_change_state(action, state);
+ surf_network_model->action_change_state(action, state);
else if (action->model_type == surf_cpu_model)
- surf_cpu_model->common_public.action_change_state(action, state);
+ surf_cpu_model->action_change_state(action, state);
else if (action->model_type == surf_workstation_model)
surf_action_change_state(action, state);
else
static surf_action_t execute(void *workstation, double size)
{
- return surf_cpu_model->extension.
- cpu.execute(((workstation_CLM03_t) workstation)->cpu, size);
+ return surf_cpu_model->extension.cpu.
+ execute(((workstation_CLM03_t) workstation)->cpu, size);
}
static surf_action_t action_sleep(void *workstation, double duration)
{
- return surf_cpu_model->extension.
- cpu.sleep(((workstation_CLM03_t) workstation)->cpu, duration);
+ return surf_cpu_model->extension.cpu.
+ sleep(((workstation_CLM03_t) workstation)->cpu, duration);
}
static void action_suspend(surf_action_t action)
{
if (action->model_type == surf_network_model)
- surf_network_model->common_public.suspend(action);
+ surf_network_model->suspend(action);
else if (action->model_type == surf_cpu_model)
- surf_cpu_model->common_public.suspend(action);
+ surf_cpu_model->suspend(action);
else
DIE_IMPOSSIBLE;
}
static void action_resume(surf_action_t action)
{
if (action->model_type == surf_network_model)
- surf_network_model->common_public.resume(action);
+ surf_network_model->resume(action);
else if (action->model_type == surf_cpu_model)
- surf_cpu_model->common_public.resume(action);
+ surf_cpu_model->resume(action);
else
DIE_IMPOSSIBLE;
}
static int action_is_suspended(surf_action_t action)
{
if (action->model_type == surf_network_model)
- return surf_network_model->common_public.is_suspended(action);
+ return surf_network_model->is_suspended(action);
if (action->model_type == surf_cpu_model)
- return surf_cpu_model->common_public.is_suspended(action);
+ return surf_cpu_model->is_suspended(action);
DIE_IMPOSSIBLE;
}
static void action_set_max_duration(surf_action_t action, double duration)
{
if (action->model_type == surf_network_model)
- surf_network_model->common_public.set_max_duration(action, duration);
+ surf_network_model->set_max_duration(action, duration);
else if (action->model_type == surf_cpu_model)
- surf_cpu_model->common_public.set_max_duration(action, duration);
+ surf_cpu_model->set_max_duration(action, duration);
else
DIE_IMPOSSIBLE;
}
static void action_set_priority(surf_action_t action, double priority)
{
if (action->model_type == surf_network_model)
- surf_network_model->common_public.set_priority(action, priority);
+ surf_network_model->set_priority(action, priority);
else if (action->model_type == surf_cpu_model)
- surf_cpu_model->common_public.set_priority(action, priority);
+ surf_cpu_model->set_priority(action, priority);
else
DIE_IMPOSSIBLE;
}
void *workstation_dst, double size,
double rate)
{
- return surf_network_model->extension.
- network.communicate(((workstation_CLM03_t) workstation_src)->network_card,
- ((workstation_CLM03_t) workstation_dst)->network_card,
- size, rate);
+ return surf_network_model->extension.network.
+ communicate(((workstation_CLM03_t) workstation_src)->network_card,
+ ((workstation_CLM03_t) workstation_dst)->network_card, size,
+ rate);
}
static e_surf_cpu_state_t get_state(void *workstation)
{
- return surf_cpu_model->extension.
- cpu.get_state(((workstation_CLM03_t) workstation)->cpu);
+ return surf_cpu_model->extension.cpu.
+ get_state(((workstation_CLM03_t) workstation)->cpu);
}
static double get_speed(void *workstation, double load)
{
- return surf_cpu_model->extension.
- cpu.get_speed(((workstation_CLM03_t) workstation)->cpu, load);
+ return surf_cpu_model->extension.cpu.
+ get_speed(((workstation_CLM03_t) workstation)->cpu, load);
}
static double get_available_speed(void *workstation)
{
- return surf_cpu_model->extension.
- cpu.get_available_speed(((workstation_CLM03_t)
- workstation)->cpu);
+ return surf_cpu_model->extension.cpu.
+ get_available_speed(((workstation_CLM03_t)
+ workstation)->cpu);
}
static xbt_dict_t get_properties(void *workstation)
{
return surf_cpu_model->
- common_public.get_properties(((workstation_CLM03_t) workstation)->cpu);
+ get_properties(((workstation_CLM03_t) workstation)->cpu);
}
static surf_action_t execute_parallel_task(int workstation_nb,
{
workstation_CLM03_t workstation_src = (workstation_CLM03_t) src;
workstation_CLM03_t workstation_dst = (workstation_CLM03_t) dst;
- return surf_network_model->extension.network.get_route(workstation_src->
- network_card,
- workstation_dst->
- network_card);
+ return surf_network_model->extension.network.
+ get_route(workstation_src->network_card, workstation_dst->network_card);
}
static int get_route_size(void *src, void *dst)
{
workstation_CLM03_t workstation_src = (workstation_CLM03_t) src;
workstation_CLM03_t workstation_dst = (workstation_CLM03_t) dst;
- return surf_network_model->extension.
- network.get_route_size(workstation_src->network_card,
- workstation_dst->network_card);
+ return surf_network_model->extension.network.
+ get_route_size(workstation_src->network_card,
+ workstation_dst->network_card);
}
static const char *get_link_name(const void *link)
surf_model_init(surf_workstation_model);
/* surf_workstation_model->extension_private = xbt_new0(s_surf_workstation_model_extension_private_t,1); */
- surf_workstation_model->common_public.get_resource_name = get_resource_name;
- surf_workstation_model->common_public.action_get_state =
- surf_action_get_state;
- 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->get_resource_name = get_resource_name;
+ surf_workstation_model->action_get_state = surf_action_get_state;
+ surf_workstation_model->action_get_start_time = surf_action_get_start_time;
+ surf_workstation_model->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_change_state =
- action_change_state;
- surf_workstation_model->common_public.action_set_data =
- surf_action_set_data;
- 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;
- surf_workstation_model->common_private->update_actions_state =
+ surf_workstation_model->action_free = action_free;
+ surf_workstation_model->action_use = action_use;
+ surf_workstation_model->action_cancel = action_cancel;
+ surf_workstation_model->action_change_state = action_change_state;
+ surf_workstation_model->action_set_data = surf_action_set_data;
+ surf_workstation_model->name = "Workstation";
+
+ surf_workstation_model->model_private->resource_used = resource_used;
+ surf_workstation_model->model_private->share_resources = share_resources;
+ surf_workstation_model->model_private->update_actions_state =
update_actions_state;
- surf_workstation_model->common_private->update_resource_state =
+ surf_workstation_model->model_private->update_resource_state =
update_resource_state;
- surf_workstation_model->common_private->finalize = finalize;
+ surf_workstation_model->model_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 =
- action_set_max_duration;
- surf_workstation_model->common_public.set_priority = action_set_priority;
+ surf_workstation_model->suspend = action_suspend;
+ surf_workstation_model->resume = action_resume;
+ surf_workstation_model->is_suspended = action_is_suspended;
+ surf_workstation_model->set_max_duration = action_set_max_duration;
+ surf_workstation_model->set_priority = action_set_priority;
surf_workstation_model->extension.workstation.execute = execute;
surf_workstation_model->extension.workstation.sleep = action_sleep;
get_available_speed;
/*manage the properties of the workstation */
- surf_workstation_model->common_public.get_properties = get_properties;
+ surf_workstation_model->get_properties = get_properties;
surf_workstation_model->extension.workstation.communicate = communicate;
surf_workstation_model->extension.workstation.execute_parallel_task =
surf_action_workstation_L07_t action = NULL;
xbt_swag_t running_actions =
- surf_workstation_model->common_public.states.running_action_set;
+ surf_workstation_model->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->states.running_action_set;
xbt_swag_foreach_safe(action, next_action, running_actions) {
deltap = delta;
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->states.running_action_set;
xbt_swag_insert(action, action->generic_action.state_set);
action->rate = rate;
surf_model_init(surf_workstation_model);
- surf_workstation_model->common_public.get_resource_name = get_resource_name;
- surf_workstation_model->common_public.action_get_state =
- surf_action_get_state;
- 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->get_resource_name = get_resource_name;
+ surf_workstation_model->action_get_state = surf_action_get_state;
+ surf_workstation_model->action_get_start_time = surf_action_get_start_time;
+ surf_workstation_model->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_change_state =
- surf_action_change_state;
- 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 =
- 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_private->resource_used = resource_used;
- surf_workstation_model->common_private->share_resources = share_resources;
- surf_workstation_model->common_private->update_actions_state =
+ surf_workstation_model->action_use = action_use;
+ surf_workstation_model->action_free = action_free;
+ surf_workstation_model->action_cancel = action_cancel;
+ surf_workstation_model->action_change_state = surf_action_change_state;
+ surf_workstation_model->action_set_data = surf_action_set_data;
+ surf_workstation_model->suspend = action_suspend;
+ surf_workstation_model->resume = action_resume;
+ surf_workstation_model->is_suspended = action_is_suspended;
+ surf_workstation_model->set_max_duration = action_set_max_duration;
+ surf_workstation_model->set_priority = action_set_priority;
+ surf_workstation_model->name = "Workstation ptask_L07";
+
+ surf_workstation_model->model_private->resource_used = resource_used;
+ surf_workstation_model->model_private->share_resources = share_resources;
+ surf_workstation_model->model_private->update_actions_state =
update_actions_state;
- surf_workstation_model->common_private->update_resource_state =
+ surf_workstation_model->model_private->update_resource_state =
update_resource_state;
- surf_workstation_model->common_private->finalize = finalize;
+ surf_workstation_model->model_private->finalize = finalize;
surf_workstation_model->extension.workstation.execute = execute;
surf_workstation_model->extension.workstation.sleep = action_sleep;
get_link_latency;
surf_workstation_model->extension.workstation.link_shared = link_shared;
- surf_workstation_model->common_public.get_properties = get_properties;
+ surf_workstation_model->get_properties = get_properties;
link_set = xbt_dict_new();
welcome here, too.
- *//*' */
+ *//*' */
xbt_log_appender_t xbt_log_default_appender = NULL; /* set in log_init */
#endif
/* some other values of possible interest: */
- /* #define breakeven_point 8 *//* VAX 4000 - vaxc */
- /* #define breakeven_point 19 *//* VAX 4000 - gcc 2.7.0 */
+ /* #define breakeven_point 8 *//* VAX 4000 - vaxc */
+ /* #define breakeven_point 19 *//* VAX 4000 - gcc 2.7.0 */
#ifndef breakeven_point
# define breakeven_point 6 /* some reasonable one-size-fits-all value */
+
+
+
xbt_context_init_factory_by_name(xbt_context_factory_t * factory,
const char *name);
/**** PBIO *****/
GRAS_DEFINE_TYPE(s_pbio, struct s_pbio { /* structure presented in the IEEE article */
- int Cnstatv;
- double Cstatev[12];
+ int Cnstatv; double Cstatev[12];
int Cnprops;
- double Cprops[110];
- int Cndi[4];
- int Cnshr;
- int Cnpt; double Cdtime; double Ctime[2]; int Cntens;
- double Cdfgrd0[373][3];
- double Cdfgrd1[3][3]; double Cstress[106];
- double Cddsdde[106][106];
- };
-
- )
+ double Cprops[110]; int Cndi[4]; int Cnshr; int Cnpt;
+ double Cdtime;
+ double Ctime[2];
+ int Cntens; double Cdfgrd0[373][3]; double Cdfgrd1[3][3];
+ double Cstress[106]; double Cddsdde[106][106];};)
typedef struct s_pbio pbio_t;
}
GRAS_DEFINE_TYPE(s_clause, struct s_clause {
- int num_lits;
- int *literals GRAS_ANNOTE(size, num_lits); /* Tells GRAS where to find the size */
- };)
+ int num_lits; int *literals GRAS_ANNOTE(size, num_lits); /* Tells GRAS where to find the size */
+ };
+
+ )
typedef struct s_clause Clause;
DEBUG1("Next Event : %g", now);
DEBUG0("\t CPU actions");
while ((action =
- xbt_swag_extract(surf_cpu_model->common_public->states.
- failed_action_set))) {
+ xbt_swag_extract(surf_cpu_model->common_public->
+ states.failed_action_set))) {
DEBUG1("\t * Failed : %p", action);
action->model_type->common_public->action_free(action);
}
while ((action =
- xbt_swag_extract(surf_cpu_model->common_public->states.
- done_action_set))) {
+ xbt_swag_extract(surf_cpu_model->common_public->
+ states.done_action_set))) {
DEBUG1("\t * Done : %p", action);
action->model_type->common_public->action_free(action);
}
DEBUG0("\t Network actions");
while ((action =
- xbt_swag_extract(surf_network_model->common_public->states.
- failed_action_set))) {
+ xbt_swag_extract(surf_network_model->common_public->
+ states.failed_action_set))) {
DEBUG1("\t * Failed : %p", action);
action->model_type->common_public->action_free(action);
}
while ((action =
- xbt_swag_extract(surf_network_model->common_public->states.
- done_action_set))) {
+ xbt_swag_extract(surf_network_model->common_public->
+ states.done_action_set))) {
DEBUG1("\t * Done : %p", action);
action->model_type->common_public->action_free(action);
}
/* Let's check that those two processors exist */
DEBUG2("%s : %p",
- surf_workstation_model->common_public->
- get_resource_name(workstationA), workstationA);
+ surf_workstation_model->
+ common_public->get_resource_name(workstationA), workstationA);
DEBUG2("%s : %p",
- surf_workstation_model->common_public->
- get_resource_name(workstationB), workstationB);
+ surf_workstation_model->
+ common_public->get_resource_name(workstationB), workstationB);
/* Let's do something on it */
actionA =
xbt_dynar_foreach(model_list, iter, model) {
DEBUG1("\t %s actions", model->common_public->name);
while ((action =
- xbt_swag_extract(model->common_public->states.
- failed_action_set))) {
+ xbt_swag_extract(model->common_public->
+ states.failed_action_set))) {
DEBUG1("\t * Failed : %p", action);
model->common_public->action_free(action);
}
while ((action =
- xbt_swag_extract(model->common_public->states.
- done_action_set))) {
+ xbt_swag_extract(model->common_public->
+ states.done_action_set))) {
DEBUG1("\t * Done : %p", action);
model->common_public->action_free(action);
}