*/
XBT_PUBLIC(surf_action_t) surf_host_model_execute_parallel_task(surf_host_model_t model,
int host_nb,
- void **host_list,
+ sg_host_t *host_list,
double *flops_amount,
double *bytes_amount,
double rate);
{
int i;
- void **surf_hosts;
+ sg_host_t *hosts;
xbt_assert(__SD_task_is_runnable_or_in_fifo(task),
"Task '%s' is not runnable or in a fifo! Task state: %d",
/* start the task */
- /* we have to create a Surf workstation array instead of the SimDag
- * workstation array */
- surf_hosts = xbt_new(void *, host_nb);
+ /* Copy the elements of the task into the action */
+ hosts = xbt_new(sg_host_t, host_nb);
for (i = 0; i < host_nb; i++)
- surf_hosts[i] = surf_host_resource_priv(task->workstation_list[i]);
+ hosts[i] = task->workstation_list[i];
double *flops_amount = xbt_new0(double, host_nb);
double *bytes_amount = xbt_new0(double, host_nb * host_nb);
task->surf_action = surf_host_model_execute_parallel_task((surf_host_model_t)surf_host_model,
host_nb,
- surf_hosts,
+ hosts,
flops_amount,
bytes_amount,
task->rate);
double *flops_amount, double *bytes_amount,
double amount, double rate){
- void **surf_host_list = NULL;
+ sg_host_t*host_list_cpy = NULL;
int i;
/* alloc structures and initialize */
synchro->category = NULL;
/* set surf's synchro */
- surf_host_list = xbt_new0(void *, host_nb);
+ host_list_cpy = xbt_new0(sg_host_t, host_nb);
for (i = 0; i < host_nb; i++)
- surf_host_list[i] = surf_host_resource_priv(host_list[i]);
+ host_list_cpy[i] = host_list[i];
/* FIXME: what happens if host_list contains VMs and PMs. If
/* set surf's synchro */
if (!MC_is_active() && !MC_record_replay_is_active()) {
synchro->execution.surf_exec =
- surf_host_model_execute_parallel_task((surf_host_model_t)surf_host_model,
- host_nb, surf_host_list, flops_amount, bytes_amount, rate);
+ surf_host_model_execute_parallel_task(surf_host_model,
+ host_nb, host_list_cpy, flops_amount, bytes_amount, rate);
surf_action_set_data(synchro->execution.surf_exec, synchro);
}
}
Action *HostCLM03Model::executeParallelTask(int host_nb,
- void **host_list,
+ sg_host_t *host_list,
double *flops_amount,
double *bytes_amount,
double rate){
Action *action =NULL;
if ((host_nb == 1)
&& (cost_or_zero(bytes_amount, 0) == 0.0)){
- action = static_cast<HostCLM03*>(host_list[0])->execute(flops_amount[0]);
+ action = surf_host_execute(host_list[0],flops_amount[0]);
} else if ((host_nb == 1)
&& (cost_or_zero(flops_amount, 0) == 0.0)) {
- action = surf_network_model->communicate(static_cast<HostCLM03*>(host_list[0])->p_netElm,
- static_cast<HostCLM03*>(host_list[0])->p_netElm,
+ action = surf_network_model->communicate(sg_host_edge(host_list[0]),
+ sg_host_edge(host_list[0]),
bytes_amount[0], rate);
} else if ((host_nb == 2)
&& (cost_or_zero(flops_amount, 0) == 0.0)
}
}
if (nb == 1){
- action = surf_network_model->communicate(static_cast<HostCLM03*>(host_list[0])->p_netElm,
- static_cast<HostCLM03*>(host_list[1])->p_netElm,
+ action = surf_network_model->communicate(sg_host_edge(host_list[0]),
+ sg_host_edge(host_list[1]),
value, rate);
}
} else
void updateActionsState(double now, double delta);
Action *executeParallelTask(int host_nb,
- void **host_list,
- double *flops_amount,
- double *bytes_amount,
- double rate);
+ sg_host_t *host_list,
+ double *flops_amount,
+ double *bytes_amount,
+ double rate);
};
/************
virtual void adjustWeightOfDummyCpuActions();
virtual Action *executeParallelTask(int host_nb,
- void **host_list,
- double *flops_amount,
- double *bytes_amount,
- double rate)=0;
+ sg_host_t *host_list,
+ double *flops_amount,
+ double *bytes_amount,
+ double rate)=0;
bool shareResourcesIsIdempotent() {return true;}
};
}
Action *HostL07Model::executeParallelTask(int host_nb,
- void **host_list,
+ sg_host_t*host_list,
double *flops_amount,
double *bytes_amount,
double rate)
action->p_edgeList->reserve(host_nb);
for (int i = 0; i<host_nb; i++)
- action->p_edgeList->push_back(static_cast<HostL07*>(host_list[i])->p_netElm);
+ action->p_edgeList->push_back(sg_host_edge(host_list[i]));
if (ptask_parallel_task_link_set == NULL)
ptask_parallel_task_link_set = xbt_dict_new_homogeneous(NULL);
for (int i = 0; i < host_nb; i++)
lmm_expand(ptask_maxmin_system,
- static_cast<HostL07*>(host_list[i])->p_cpu->getConstraint(),
+ sg_host_surfcpu(host_list[i])->getConstraint(),
action->getVariable(), flops_amount[i]);
for (int i = 0; i < host_nb; i++) {
Action *NetworkL07Model::communicate(RoutingEdge *src, RoutingEdge *dst,
double size, double rate)
{
- void **host_list = xbt_new0(void *, 2);
+ sg_host_t*host_list = xbt_new0(sg_host_t, 2);
double *flops_amount = xbt_new0(double, 2);
double *bytes_amount = xbt_new0(double, 4);
Action *res = NULL;
- host_list[0] = xbt_lib_get_level(xbt_lib_get_elm_or_null(host_lib, src->getName()), SURF_HOST_LEVEL);
- host_list[1] = xbt_lib_get_level(xbt_lib_get_elm_or_null(host_lib, dst->getName()), SURF_HOST_LEVEL);
+ host_list[0] = sg_host_by_name(src->getName());
+ host_list[1] = sg_host_by_name(dst->getName());
bytes_amount[1] = size;
res = p_hostModel->executeParallelTask(2, host_list,
Action *HostL07::execute(double size)
{
- void **host_list = xbt_new0(void *, 1);
+ sg_host_t*host_list = xbt_new0(sg_host_t, 1);
double *flops_amount = xbt_new0(double, 1);
double *bytes_amount = xbt_new0(double, 1);
- host_list[0] = this;
- bytes_amount[0] = 0.0;
+ host_list[0] = sg_host_by_name(getName());
flops_amount[0] = size;
return static_cast<HostL07Model*>(getModel())->executeParallelTask(1, host_list,
void updateActionsState(double now, double delta);
Host *createHost(const char *name);
Action *executeParallelTask(int host_nb,
- void **host_list,
- double *flops_amount,
- double *bytes_amount,
- double rate);
+ sg_host_t *host_list,
+ double *flops_amount,
+ double *bytes_amount,
+ double rate);
xbt_dynar_t getRoute(Host *src, Host *dst);
void addTraces();
NetworkModel *p_networkModel;
friend Action *HostL07::execute(double size);
friend Action *HostL07::sleep(double duration);
friend Action *HostL07Model::executeParallelTask(int host_nb,
- void **host_list,
+ sg_host_t*host_list,
double *flops_amount,
double *bytes_amount,
double rate);
*/
class NetworkAction : public Action {
public:
- /**
- * @brief NetworkAction constructor
+ /** @brief Constructor
*
* @param model The NetworkModel associated to this NetworkAction
* @param cost The cost of this NetworkAction in [TODO]
surf_action_t surf_host_model_execute_parallel_task(surf_host_model_t model,
int host_nb,
- void **host_list,
+ sg_host_t *host_list,
double *flops_amount,
double *bytes_amount,
double rate){
}
Action *VMHL13Model::executeParallelTask(int host_nb,
- void **host_list,
- double *flops_amount,
- double *bytes_amount,
- double rate){
+ sg_host_t *host_list,
+ double *flops_amount,
+ double *bytes_amount,
+ double rate){
#define cost_or_zero(array,pos) ((array)?(array)[pos]:0.0)
if ((host_nb == 1)
&& (cost_or_zero(bytes_amount, 0) == 0.0))
- return static_cast<HostCLM03*>(host_list[0])->execute(flops_amount[0]);
+ return surf_host_execute(host_list[0], flops_amount[0]);
else if ((host_nb == 1)
&& (cost_or_zero(flops_amount, 0) == 0.0))
- return surf_network_model->communicate(static_cast<HostCLM03*>(host_list[0])->p_netElm, static_cast<HostCLM03*>(host_list[0])->p_netElm,bytes_amount[0], rate);
+ return surf_network_model_communicate(surf_network_model, host_list[0], host_list[0],bytes_amount[0], rate);
else if ((host_nb == 2)
&& (cost_or_zero(flops_amount, 0) == 0.0)
&& (cost_or_zero(flops_amount, 1) == 0.0)) {
}
}
if (nb == 1)
- return surf_network_model->communicate(static_cast<HostCLM03*>(host_list[0])->p_netElm, static_cast<HostCLM03*>(host_list[1])->p_netElm,value, rate);
+ return surf_network_model_communicate(surf_network_model, host_list[0], host_list[1], value, rate);
}
#undef cost_or_zero
double shareResources(double now);
void adjustWeightOfDummyCpuActions() {};
Action *executeParallelTask(int host_nb,
- void **host_list,
- double *flops_amount,
- double *bytes_amount,
- double rate);
+ sg_host_t *host_list,
+ double *flops_amount,
+ double *bytes_amount,
+ double rate);
void updateActionsState(double /*now*/, double /*delta*/);
};