X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/399e4077a352ec6e0ad4134e5645a29d0d241c88..a92872978cf9cc16a34a4a8ea0c9d0866187decc:/src/surf/workstation_ptask_L07.cpp diff --git a/src/surf/workstation_ptask_L07.cpp b/src/surf/workstation_ptask_L07.cpp index 4bf426f1ba..f25aa1f83c 100644 --- a/src/surf/workstation_ptask_L07.cpp +++ b/src/surf/workstation_ptask_L07.cpp @@ -1,11 +1,11 @@ -/* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team. +/* Copyright (c) 2007-2010, 2013. 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 "workstation_ptask_L07.hpp" -#include "cpu.hpp" +#include "cpu_interface.hpp" #include "surf_routing.hpp" XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_workstation); @@ -17,29 +17,42 @@ lmm_system_t ptask_maxmin_system = NULL; WorkstationL07Model::WorkstationL07Model() : WorkstationModel("Workstation ptask_L07") { if (!ptask_maxmin_system) ptask_maxmin_system = lmm_system_new(1); - routing_model_create(createLinkResource("__loopback__", + surf_workstation_model = NULL; + surf_network_model = new NetworkL07Model(); + surf_cpu_model_pm = new CpuL07Model(); + routing_model_create(static_cast(surf_network_model->createResource("__loopback__", 498000000, NULL, 0.000015, NULL, SURF_RESOURCE_ON, NULL, - SURF_LINK_FATPIPE, NULL)); + SURF_LINK_FATPIPE, NULL))); + p_cpuModel = surf_cpu_model_pm; +} + +WorkstationL07Model::~WorkstationL07Model() { + xbt_dict_free(&ptask_parallel_task_link_set); - surf_network_model = new NetworkL07Model(); + delete surf_cpu_model_pm; + delete surf_network_model; + ptask_host_count = 0; + + if (ptask_maxmin_system) { + lmm_system_free(ptask_maxmin_system); + ptask_maxmin_system = NULL; + } } -double WorkstationL07Model::shareResources(double now) +double WorkstationL07Model::shareResources(double /*now*/) { void *_action; WorkstationL07ActionLmmPtr action; - xbt_swag_t running_actions = surf_workstation_model->p_runningActionSet; + xbt_swag_t running_actions = this->p_runningActionSet; double min = this->shareResourcesMaxMin(running_actions, - xbt_swag_offset((*action), - p_variable), ptask_maxmin_system, bottleneck_solve); xbt_swag_foreach(_action, running_actions) { - action = (WorkstationL07ActionLmmPtr) _action; + action = dynamic_cast(static_cast(_action)); if (action->m_latency > 0) { if (min < 0) { min = action->m_latency; @@ -58,16 +71,15 @@ double WorkstationL07Model::shareResources(double now) return min; } -void WorkstationL07Model::updateActionsState(double now, double delta) +void WorkstationL07Model::updateActionsState(double /*now*/, double delta) { double deltap = 0.0; void *_action, *_next_action; WorkstationL07ActionLmmPtr action; - xbt_swag_t running_actions = - surf_workstation_model->p_runningActionSet; - xbt_swag_foreach_safe(_action, _next_action, running_actions) { - action = (WorkstationL07ActionLmmPtr) _action; + xbt_swag_foreach_safe(_action, _next_action, p_runningActionSet) { + action = dynamic_cast(static_cast(_action)); + deltap = delta; if (action->m_latency > 0) { if (action->m_latency > deltap) { @@ -109,7 +121,7 @@ void WorkstationL07Model::updateActionsState(double now, double delta) i++))) { constraint_id = lmm_constraint_id(cnst); - if (((WorkstationCLM03LmmPtr)constraint_id)->p_stateCurrent == SURF_RESOURCE_OFF) { + if (static_cast(constraint_id)->p_stateCurrent == SURF_RESOURCE_OFF) { XBT_DEBUG("Action (%p) Failed!!", action); action->m_finish = surf_get_clock(); action->setState(SURF_ACTION_FAILED); @@ -148,13 +160,22 @@ ActionPtr WorkstationL07Model::executeParallelTask(int workstation_nb, if (communication_amount[i * workstation_nb + j] > 0) { double lat=0.0; unsigned int cpt; + void *_link; LinkL07Ptr link; - routing_platf->getRouteAndLatency(((CpuL07Ptr)workstation_list[i])->p_info, ((CpuL07Ptr)workstation_list[j])->p_info, &route,&lat); + routing_platf->getRouteAndLatency(dynamic_cast( + static_cast( + workstation_list[i]))->p_netElm, + dynamic_cast( + static_cast( + workstation_list[j]))->p_netElm, + &route, + &lat); latency = MAX(latency, lat); - xbt_dynar_foreach(route, cpt, link) { - xbt_dict_set(ptask_parallel_task_link_set,link->m_name,link,NULL); + xbt_dynar_foreach(route, cpt, _link) { + link = dynamic_cast(static_cast(_link)); + xbt_dict_set(ptask_parallel_task_link_set, link->m_name, link, NULL); } } } @@ -173,7 +194,7 @@ ActionPtr WorkstationL07Model::executeParallelTask(int workstation_nb, action->m_suspended = 0; /* Should be useless because of the calloc but it seems to help valgrind... */ action->m_workstationNb = workstation_nb; - action->p_workstationList = (WorkstationCLM03Ptr *) workstation_list; + action->p_workstationList = (WorkstationPtr *) workstation_list; action->p_computationAmount = computation_amount; action->p_communicationAmount = communication_amount; action->m_latency = latency; @@ -187,19 +208,28 @@ ActionPtr WorkstationL07Model::executeParallelTask(int workstation_nb, lmm_update_variable_weight(ptask_maxmin_system, action->p_variable, 0.0); for (i = 0; i < workstation_nb; i++) - lmm_expand(ptask_maxmin_system, ((CpuL07Ptr)workstation_list[i])->p_constraint, + lmm_expand(ptask_maxmin_system, + static_cast(dynamic_cast( + static_cast(workstation_list[i]))->p_cpu)->p_constraint, action->p_variable, computation_amount[i]); for (i = 0; i < workstation_nb; i++) { for (j = 0; j < workstation_nb; j++) { + void *_link; LinkL07Ptr link; + xbt_dynar_t route=NULL; if (communication_amount[i * workstation_nb + j] == 0.0) continue; - routing_platf->getRouteAndLatency(((CpuL07Ptr)workstation_list[i])->p_info, ((CpuL07Ptr)workstation_list[j])->p_info, &route,NULL); + routing_platf->getRouteAndLatency(dynamic_cast( + static_cast(workstation_list[i]))->p_netElm, + dynamic_cast( + static_cast(workstation_list[j]))->p_netElm, + &route, NULL); - xbt_dynar_foreach(route, cpt, link) { + xbt_dynar_foreach(route, cpt, _link) { + link = dynamic_cast(static_cast(_link)); lmm_expand_add(ptask_maxmin_system, link->p_constraint, action->p_variable, communication_amount[i * workstation_nb + j]); @@ -212,10 +242,31 @@ ActionPtr WorkstationL07Model::executeParallelTask(int workstation_nb, action->m_remains = 0.0; } - return (surf_action_t) action; + return static_cast(action); +} + +ResourcePtr WorkstationL07Model::createResource(const char *name, double /*power_scale*/, + double /*power_initial*/, + tmgr_trace_t /*power_trace*/, + e_surf_resource_state_t /*state_initial*/, + tmgr_trace_t /*state_trace*/, + xbt_dict_t /*cpu_properties*/) +{ + WorkstationL07Ptr wk = NULL; + xbt_assert(!surf_workstation_resource_priv(surf_workstation_resource_by_name(name)), + "Host '%s' declared several times in the platform file.", + name); + + wk = new WorkstationL07(this, name, NULL, + static_cast(xbt_lib_get_or_null(host_lib, name, ROUTING_HOST_LEVEL)), + dynamic_cast(static_cast(xbt_lib_get_or_null(host_lib, name, SURF_CPU_LEVEL)))); + + xbt_lib_set(host_lib, name, SURF_WKS_LEVEL, static_cast(wk)); + + return wk;//FIXME:xbt_lib_get_elm_or_null(host_lib, name); } -ActionPtr WorkstationL07Model::communicate(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst, +ActionPtr WorkstationL07Model::communicate(WorkstationPtr src, WorkstationPtr dst, double size, double rate) { void **workstation_list = xbt_new0(void *, 2); @@ -223,8 +274,8 @@ ActionPtr WorkstationL07Model::communicate(WorkstationCLM03Ptr src, WorkstationC double *communication_amount = xbt_new0(double, 4); ActionPtr res = NULL; - workstation_list[0] = src; - workstation_list[1] = dst; + workstation_list[0] = static_cast(src); + workstation_list[1] = static_cast(dst); communication_amount[1] = size; res = executeParallelTask(2, workstation_list, @@ -234,14 +285,14 @@ ActionPtr WorkstationL07Model::communicate(WorkstationCLM03Ptr src, WorkstationC return res; } -xbt_dynar_t WorkstationL07Model::getRoute(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst) +xbt_dynar_t WorkstationL07Model::getRoute(WorkstationPtr src, WorkstationPtr dst) { xbt_dynar_t route=NULL; - routing_platf->getRouteAndLatency(((CpuL07Ptr)src)->p_info, ((CpuL07Ptr)dst)->p_info, &route,NULL); + routing_platf->getRouteAndLatency(src->p_netElm, dst->p_netElm, &route, NULL); return route; } -WorkstationCLM03Ptr WorkstationL07Model::createCpuResource(const char *name, double power_scale, +ResourcePtr CpuL07Model::createResource(const char *name, double power_scale, double power_initial, tmgr_trace_t power_trace, e_surf_resource_state_t state_initial, @@ -255,32 +306,29 @@ WorkstationCLM03Ptr WorkstationL07Model::createCpuResource(const char *name, dou cpu = new CpuL07(this, name, cpu_properties); - cpu->p_info = (RoutingEdgePtr) xbt_lib_get_or_null(host_lib, name, ROUTING_HOST_LEVEL); - if(!(cpu->p_info)) xbt_die("Don't find ROUTING_HOST_LEVEL for '%s'",name); - cpu->p_power.scale = power_scale; xbt_assert(cpu->p_power.scale > 0, "Power has to be >0"); cpu->m_powerCurrent = power_initial; if (power_trace) cpu->p_power.event = - tmgr_history_add_trace(history, power_trace, 0.0, 0, cpu); + tmgr_history_add_trace(history, power_trace, 0.0, 0, static_cast(cpu)); cpu->p_stateCurrent = state_initial; if (state_trace) cpu->p_stateEvent = - tmgr_history_add_trace(history, state_trace, 0.0, 0, cpu); + tmgr_history_add_trace(history, state_trace, 0.0, 0, static_cast(cpu)); cpu->p_constraint = lmm_constraint_new(ptask_maxmin_system, cpu, cpu->m_powerCurrent * cpu->p_power.scale); - xbt_lib_set(host_lib, name, SURF_WKS_LEVEL, static_cast(cpu)); + xbt_lib_set(host_lib, name, SURF_CPU_LEVEL, static_cast(cpu)); return cpu;//FIXME:xbt_lib_get_elm_or_null(host_lib, name); } -WorkstationCLM03Ptr WorkstationL07Model::createLinkResource(const char *name, +NetworkLinkPtr NetworkL07Model::createResource(const char *name, double bw_initial, tmgr_trace_t bw_trace, double lat_initial, @@ -291,7 +339,7 @@ WorkstationCLM03Ptr WorkstationL07Model::createLinkResource(const char *name, e_surf_link_sharing_policy_t policy, xbt_dict_t properties) { - LinkL07Ptr nw_link = new LinkL07(this, xbt_strdup(name), properties); + LinkL07Ptr nw_link = new LinkL07(this, name, properties); xbt_assert(!xbt_lib_get_or_null(link_lib, name, SURF_LINK_LEVEL), "Link '%s' declared several times in the platform file.", name); @@ -299,15 +347,15 @@ WorkstationCLM03Ptr WorkstationL07Model::createLinkResource(const char *name, nw_link->m_bwCurrent = bw_initial; if (bw_trace) nw_link->p_bwEvent = - tmgr_history_add_trace(history, bw_trace, 0.0, 0, nw_link); + tmgr_history_add_trace(history, bw_trace, 0.0, 0, static_cast(nw_link)); nw_link->p_stateCurrent = state_initial; nw_link->m_latCurrent = lat_initial; if (lat_trace) nw_link->p_latEvent = - tmgr_history_add_trace(history, lat_trace, 0.0, 0, nw_link); + tmgr_history_add_trace(history, lat_trace, 0.0, 0, static_cast(nw_link)); if (state_trace) nw_link->p_stateEvent = - tmgr_history_add_trace(history, state_trace, 0.0, 0, nw_link); + tmgr_history_add_trace(history, state_trace, 0.0, 0, static_cast(nw_link)); nw_link->p_constraint = lmm_constraint_new(ptask_maxmin_system, nw_link, @@ -316,7 +364,7 @@ WorkstationCLM03Ptr WorkstationL07Model::createLinkResource(const char *name, if (policy == SURF_LINK_FATPIPE) lmm_constraint_shared(nw_link->p_constraint); - xbt_lib_set(link_lib, name, SURF_LINK_LEVEL, nw_link); + xbt_lib_set(link_lib, name, SURF_LINK_LEVEL, static_cast(nw_link)); return nw_link; } @@ -331,53 +379,59 @@ void WorkstationL07Model::addTraces() /* Connect traces relative to cpu */ xbt_dict_foreach(trace_connect_list_host_avail, cursor, trace_name, elm) { tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name); - CpuL07Ptr host = (CpuL07Ptr) surf_workstation_resource_priv(surf_workstation_resource_by_name(elm)); + CpuL07Ptr host = dynamic_cast( + static_cast( + surf_cpu_resource_priv( + surf_cpu_resource_by_name(elm)))); 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, host); + host->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast(host)); } xbt_dict_foreach(trace_connect_list_power, cursor, trace_name, elm) { tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name); - CpuL07Ptr host = (CpuL07Ptr) surf_workstation_resource_priv(surf_workstation_resource_by_name(elm)); + CpuL07Ptr host = dynamic_cast( + static_cast( + surf_cpu_resource_priv( + surf_cpu_resource_by_name(elm)))); xbt_assert(host, "Host %s undefined", elm); xbt_assert(trace, "Trace %s undefined", trace_name); - host->p_power.event = tmgr_history_add_trace(history, trace, 0.0, 0, host); + host->p_power.event = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast(host)); } /* Connect traces relative to network */ xbt_dict_foreach(trace_connect_list_link_avail, cursor, trace_name, elm) { tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name); - LinkL07Ptr link = (LinkL07Ptr) xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL); + LinkL07Ptr link = dynamic_cast(static_cast(xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL))); 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, link); + link->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast(link)); } xbt_dict_foreach(trace_connect_list_bandwidth, cursor, trace_name, elm) { tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name); - LinkL07Ptr link = (LinkL07Ptr) xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL); + LinkL07Ptr link = dynamic_cast(static_cast(xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL))); 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, link); + link->p_bwEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast(link)); } xbt_dict_foreach(trace_connect_list_latency, cursor, trace_name, elm) { tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name); - LinkL07Ptr link = (LinkL07Ptr) xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL); + LinkL07Ptr link = dynamic_cast(static_cast(xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL))); 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, link); + link->p_latEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast(link)); } } @@ -385,11 +439,43 @@ void WorkstationL07Model::addTraces() * Resource * ************/ -CpuL07::CpuL07(WorkstationL07ModelPtr model, const char* name, xbt_dict_t props) : WorkstationCLM03Lmm(model, name, props) { +WorkstationL07::WorkstationL07(WorkstationModelPtr model, const char* name, xbt_dict_t props, RoutingEdgePtr netElm, CpuPtr cpu) + : Resource(model, name, props), + Workstation(NULL, netElm, cpu), + WorkstationLmm() +{ +} + +double WorkstationL07::getPowerPeakAt(int /*pstate_index*/) +{ + XBT_DEBUG("[ws_get_power_peak_at] Not implemented for workstation_ptask_L07"); + return 0.0; +} + +int WorkstationL07::getNbPstates() +{ + XBT_DEBUG("[ws_get_nb_pstates] Not implemented for workstation_ptask_L07"); + return 0.0; +} + +void WorkstationL07::setPowerPeakAt(int /*pstate_index*/) +{ + XBT_DEBUG("[ws_set_power_peak_at] Not implemented for workstation_ptask_L07"); +} + +double WorkstationL07::getConsumedEnergy() +{ + XBT_DEBUG("[ws_get_consumed_energy] Not implemented for workstation_ptask_L07"); + return 0.0; +} + +CpuL07::CpuL07(CpuL07ModelPtr model, const char* name, xbt_dict_t props) + : Resource(model, name, props), CpuLmm() { } -LinkL07::LinkL07(WorkstationL07ModelPtr model, const char* name, xbt_dict_t props) : WorkstationCLM03Lmm(model, name, props) { +LinkL07::LinkL07(NetworkL07ModelPtr model, const char* name, xbt_dict_t props) + : Resource(model, name, props), NetworkLinkLmm() { } @@ -401,7 +487,7 @@ bool LinkL07::isUsed(){ return lmm_constraint_used(ptask_maxmin_system, p_constraint); } -void CpuL07::updateState(tmgr_trace_event_t event_type, double value, double date){ +void CpuL07::updateState(tmgr_trace_event_t event_type, double value, double /*date*/){ XBT_DEBUG("Updating cpu %s (%p) with value %g", m_name, this, value); if (event_type == p_power.event) { m_powerCurrent = value; @@ -455,6 +541,10 @@ void LinkL07::updateState(tmgr_trace_event_t event_type, double value, double da return; } +e_surf_resource_state_t WorkstationL07::getState() +{ + return p_cpu->p_stateCurrent; +} e_surf_resource_state_t CpuL07::getState() { @@ -471,22 +561,22 @@ double CpuL07::getAvailableSpeed() return m_powerCurrent; } -ActionPtr CpuL07::execute(double size) +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); - workstation_list[0] = this; + workstation_list[0] = static_cast(this); communication_amount[0] = 0.0; computation_amount[0] = size; - return ((WorkstationL07ModelPtr)p_model)->executeParallelTask(1, workstation_list, + return static_cast(p_model)->executeParallelTask(1, workstation_list, computation_amount, communication_amount, -1); } -ActionPtr CpuL07::sleep(double duration) +ActionPtr WorkstationL07::sleep(double duration) { WorkstationL07ActionLmmPtr action = NULL; @@ -541,7 +631,11 @@ void WorkstationL07ActionLmm::updateBound() if (p_communicationAmount[i * m_workstationNb + j] > 0) { double lat = 0.0; - routing_platf->getRouteAndLatency(((CpuL07Ptr) p_workstationList[i])->p_info, ((CpuL07Ptr)p_workstationList[j])->p_info, &route, &lat); + routing_platf->getRouteAndLatency(dynamic_cast( + static_cast(((void**)p_workstationList)[i]))->p_netElm, + dynamic_cast( + static_cast(((void**)p_workstationList)[j]))->p_netElm, + &route, &lat); lat_current = MAX(lat_current, lat * p_communicationAmount[i * m_workstationNb + j]); } @@ -622,15 +716,7 @@ double WorkstationL07ActionLmm::getRemains() return m_remains; } - - - - - - - - -static void ptask_finalize(void) +/*static void ptask_finalize(void) { xbt_dict_free(&ptask_parallel_task_link_set); @@ -645,7 +731,7 @@ static void ptask_finalize(void) lmm_system_free(ptask_maxmin_system); ptask_maxmin_system = NULL; } -} + }*/ /**************************************/ /******* Resource Private **********/ @@ -670,13 +756,27 @@ static void ptask_finalize(void) /*** Resource Creation & Destruction **/ /**************************************/ - +static void ptask_parse_workstation_init(sg_platf_host_cbarg_t host) +{ + double power_peak = xbt_dynar_get_as(host->power_peak, host->pstate, double); + //cpu->power_peak = power_peak; + xbt_dynar_free(&(host->power_peak)); /* kill memory leak */ + static_cast(surf_workstation_model)->createResource( + host->id, + power_peak, + host->power_scale, + host->power_trace, + host->initial_state, + host->state_trace, + host->properties); +} static void ptask_parse_cpu_init(sg_platf_host_cbarg_t host) { - ((WorkstationL07ModelPtr)surf_workstation_model)->createCpuResource( + double power_peak = xbt_dynar_get_as(host->power_peak, host->pstate, double); + static_cast(surf_cpu_model_pm)->createResource( host->id, - host->power_peak, + power_peak, host->power_scale, host->power_trace, host->initial_state, @@ -691,7 +791,7 @@ static void ptask_parse_link_init(sg_platf_link_cbarg_t link) if (link->policy == SURF_LINK_FULLDUPLEX) { char *link_id; link_id = bprintf("%s_UP", link->id); - ((WorkstationL07ModelPtr)surf_workstation_model)->createLinkResource(link_id, + static_cast(surf_network_model)->createResource(link_id, link->bandwidth, link->bandwidth_trace, link->latency, @@ -702,7 +802,7 @@ static void ptask_parse_link_init(sg_platf_link_cbarg_t link) link->properties); xbt_free(link_id); link_id = bprintf("%s_DOWN", link->id); - ((WorkstationL07ModelPtr)surf_workstation_model)->createLinkResource(link_id, + static_cast(surf_network_model)->createResource(link_id, link->bandwidth, link->bandwidth_trace, link->latency, @@ -715,7 +815,7 @@ static void ptask_parse_link_init(sg_platf_link_cbarg_t link) * it */ xbt_free(link_id); } else { - ((WorkstationL07ModelPtr)surf_workstation_model)->createLinkResource(link->id, + static_cast(surf_network_model)->createResource(link->id, link->bandwidth, link->bandwidth_trace, link->latency, @@ -729,13 +829,16 @@ static void ptask_parse_link_init(sg_platf_link_cbarg_t link) current_property_set = NULL; } - +static void ptask_add_traces(){ + static_cast(surf_workstation_model)->addTraces(); +} static void ptask_define_callbacks() { sg_platf_host_add_cb(ptask_parse_cpu_init); + sg_platf_host_add_cb(ptask_parse_workstation_init); sg_platf_link_add_cb(ptask_parse_link_init); - //FIXME:sg_platf_postparse_add_cb(ptask_add_traces); + sg_platf_postparse_add_cb(ptask_add_traces); } /**************************************/ @@ -744,9 +847,11 @@ static void ptask_define_callbacks() void surf_workstation_model_init_ptask_L07(void) { XBT_INFO("surf_workstation_model_init_ptask_L07"); - xbt_assert(!surf_cpu_model, "CPU model type already defined"); + xbt_assert(!surf_cpu_model_pm, "CPU model type already defined"); xbt_assert(!surf_network_model, "network model type already defined"); ptask_define_callbacks(); - new WorkstationL07Model(); - xbt_dynar_push(model_list, &surf_workstation_model); + surf_workstation_model = new WorkstationL07Model(); + ModelPtr model = static_cast(surf_workstation_model); + xbt_dynar_push(model_list, &model); + xbt_dynar_push(model_list_invoke, &model); }