surf_workstation_model = NULL;
surf_network_model = new NetworkL07Model();
surf_cpu_model_pm = new CpuL07Model();
- routing_model_create(static_cast<ResourcePtr>(surf_network_model->createNetworkLink("__loopback__",
+ routing_model_create(surf_network_model->createNetworkLink("__loopback__",
498000000, NULL,
0.000015, NULL,
SURF_RESOURCE_ON, NULL,
- SURF_LINK_FATPIPE, NULL)));
+ SURF_LINK_FATPIPE, NULL));
p_cpuModel = surf_cpu_model_pm;
}
ActionPtr WorkstationL07Model::executeParallelTask(int workstation_nb,
void **workstation_list,
- double
- *computation_amount, double
- *communication_amount,
- double rate)
+ double *flops_amount,
+ double *bytes_amount,
+ double rate)
{
WorkstationL07ActionPtr action;
int i, j;
for (j = 0; j < workstation_nb; j++) {
xbt_dynar_t route=NULL;
- if (communication_amount[i * workstation_nb + j] > 0) {
+ if (bytes_amount[i * workstation_nb + j] > 0) {
double lat=0.0;
unsigned int cpt;
void *_link;
xbt_dict_reset(ptask_parallel_task_link_set);
for (i = 0; i < workstation_nb; i++)
- if (computation_amount[i] > 0)
+ if (flops_amount[i] > 0)
nb_host++;
action = new WorkstationL07Action(this, 1, 0);
calloc but it seems to help valgrind... */
action->m_workstationNb = workstation_nb;
action->p_workstationList = (WorkstationPtr *) workstation_list;
- action->p_computationAmount = computation_amount;
- action->p_communicationAmount = communication_amount;
+ action->p_computationAmount = flops_amount;
+ action->p_communicationAmount = bytes_amount;
action->m_latency = latency;
action->m_rate = rate;
for (i = 0; i < workstation_nb; i++)
lmm_expand(ptask_maxmin_system,
- static_cast<CpuPtr>(static_cast<WorkstationL07Ptr>(workstation_list[i])->p_cpu)->getConstraint(),
- action->getVariable(), computation_amount[i]);
+ static_cast<WorkstationL07Ptr>(workstation_list[i])->p_cpu->getConstraint(),
+ action->getVariable(), flops_amount[i]);
for (i = 0; i < workstation_nb; i++) {
for (j = 0; j < workstation_nb; j++) {
LinkL07Ptr link;
xbt_dynar_t route=NULL;
- if (communication_amount[i * workstation_nb + j] == 0.0)
+ if (bytes_amount[i * workstation_nb + j] == 0.0)
continue;
routing_platf->getRouteAndLatency(static_cast<WorkstationL07Ptr>(workstation_list[i])->p_netElm,
link = static_cast<LinkL07Ptr>(_link);
lmm_expand_add(ptask_maxmin_system, link->getConstraint(),
action->getVariable(),
- communication_amount[i * workstation_nb + j]);
+ bytes_amount[i * workstation_nb + j]);
}
}
}
action->setRemains(0.0);
}
- return static_cast<ActionPtr>(action);
+ return action;
}
WorkstationPtr WorkstationL07Model::createWorkstation(const char *name)
static_cast<RoutingEdgePtr>(xbt_lib_get_or_null(host_lib, name, ROUTING_HOST_LEVEL)),
static_cast<CpuPtr>(xbt_lib_get_or_null(host_lib, name, SURF_CPU_LEVEL)));
- xbt_lib_set(host_lib, name, SURF_WKS_LEVEL, static_cast<ResourcePtr>(wk));
+ xbt_lib_set(host_lib, name, SURF_WKS_LEVEL, wk);
return wk;//FIXME:xbt_lib_get_elm_or_null(host_lib, name);
}
double size, double rate)
{
void **workstation_list = xbt_new0(void *, 2);
- double *computation_amount = xbt_new0(double, 2);
- double *communication_amount = xbt_new0(double, 4);
+ double *flops_amount = xbt_new0(double, 2);
+ double *bytes_amount = xbt_new0(double, 4);
ActionPtr res = NULL;
- workstation_list[0] = static_cast<ResourcePtr>(src);
- workstation_list[1] = static_cast<ResourcePtr>(dst);
- communication_amount[1] = size;
+ workstation_list[0] = src;
+ workstation_list[1] = dst;
+ bytes_amount[1] = size;
res = executeParallelTask(2, workstation_list,
- computation_amount,
- communication_amount, rate);
+ flops_amount,
+ bytes_amount, rate);
return res;
}
xbt_dict_t cpu_properties)
{
double power_initial = xbt_dynar_get_as(powerPeak, pstate, double);
+ xbt_dynar_free(&powerPeak); // kill memory leak
xbt_assert(!surf_workstation_resource_priv(surf_workstation_resource_by_name(name)),
"Host '%s' declared several times in the platform file.",
power_initial, power_scale, power_trace,
core, state_initial, state_trace);
- xbt_lib_set(host_lib, name, SURF_CPU_LEVEL, static_cast<ResourcePtr>(cpu));
+ xbt_lib_set(host_lib, name, SURF_CPU_LEVEL, cpu);
- return cpu;//FIXME:xbt_lib_get_elm_or_null(host_lib, name);
+ return cpu;
}
NetworkLinkPtr NetworkL07Model::createNetworkLink(const char *name,
state_initial, state_trace,
policy);
- xbt_lib_set(link_lib, name, SURF_LINK_LEVEL, static_cast<ResourcePtr>(nw_link));
+ xbt_lib_set(link_lib, name, SURF_LINK_LEVEL, nw_link);
return nw_link;
}
xbt_assert(host, "Host %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
- host->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(host));
+ host->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, host);
}
xbt_dict_foreach(trace_connect_list_power, cursor, trace_name, elm) {
xbt_assert(host, "Host %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
- host->p_powerEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(host));
+ host->p_powerEvent = tmgr_history_add_trace(history, trace, 0.0, 0, host);
}
/* Connect traces relative to network */
xbt_assert(link, "Link %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
- link->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(link));
+ link->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, link);
}
xbt_dict_foreach(trace_connect_list_bandwidth, cursor, trace_name, elm) {
xbt_assert(link, "Link %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
- link->p_bwEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(link));
+ link->p_bwEvent = tmgr_history_add_trace(history, trace, 0.0, 0, link);
}
xbt_dict_foreach(trace_connect_list_latency, cursor, trace_name, elm) {
xbt_assert(link, "Link %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
- link->p_latEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(link));
+ link->p_latEvent = tmgr_history_add_trace(history, trace, 0.0, 0, link);
}
}
xbt_assert(m_powerScale > 0, "Power has to be >0");
if (power_trace)
- p_powerEvent = tmgr_history_add_trace(history, power_trace, 0.0, 0,
- static_cast<ResourcePtr>(this));
+ p_powerEvent = tmgr_history_add_trace(history, power_trace, 0.0, 0, this);
else
p_powerEvent = NULL;
setState(state_initial);
if (state_trace)
- p_stateEvent = tmgr_history_add_trace(history, state_trace, 0.0, 0, static_cast<ResourcePtr>(this));
+ p_stateEvent = tmgr_history_add_trace(history, state_trace, 0.0, 0, this);
}
LinkL07::LinkL07(NetworkL07ModelPtr model, const char* name, xbt_dict_t props,
{
m_bwCurrent = bw_initial;
if (bw_trace)
- p_bwEvent = tmgr_history_add_trace(history, bw_trace, 0.0, 0, static_cast<ResourcePtr>(this));
+ p_bwEvent = tmgr_history_add_trace(history, bw_trace, 0.0, 0, this);
setState(state_initial);
m_latCurrent = lat_initial;
if (lat_trace)
- p_latEvent = tmgr_history_add_trace(history, lat_trace, 0.0, 0, static_cast<ResourcePtr>(this));
+ p_latEvent = tmgr_history_add_trace(history, lat_trace, 0.0, 0, this);
if (policy == SURF_LINK_FATPIPE)
lmm_constraint_shared(getConstraint());
ActionPtr WorkstationL07::execute(double size)
{
void **workstation_list = xbt_new0(void *, 1);
- double *computation_amount = xbt_new0(double, 1);
- double *communication_amount = xbt_new0(double, 1);
+ double *flops_amount = xbt_new0(double, 1);
+ double *bytes_amount = xbt_new0(double, 1);
- workstation_list[0] = static_cast<ResourcePtr>(this);
- communication_amount[0] = 0.0;
- computation_amount[0] = size;
+ workstation_list[0] = this;
+ bytes_amount[0] = 0.0;
+ flops_amount[0] = size;
return static_cast<WorkstationL07ModelPtr>(getModel())->executeParallelTask(1, workstation_list,
- computation_amount,
- communication_amount, -1);
+ flops_amount,
+ bytes_amount, -1);
}
ActionPtr WorkstationL07::sleep(double duration)