X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/3196e54e1f004f07f2348d059f351b95146732ef..f8f0be85ee23b69476ce45197e33bb96bfdbdd98:/src/surf/workstation_KCCFLN05.c diff --git a/src/surf/workstation_KCCFLN05.c b/src/surf/workstation_KCCFLN05.c index 956d49de51..49173ae975 100644 --- a/src/surf/workstation_KCCFLN05.c +++ b/src/surf/workstation_KCCFLN05.c @@ -5,700 +5,537 @@ /* 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 "xbt/ex.h" #include "xbt/dict.h" #include "workstation_KCCFLN05_private.h" -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(workstation_KCCFLN05, surf, +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_workstation, surf, "Logging specific to the SURF workstation module (KCCFLN05)"); - -static lmm_system_t maxmin_system_cpu_KCCFLN05 = NULL; -static lmm_system_t maxmin_system_network_KCCFLN05 = NULL; -static xbt_dict_t network_link_set = NULL; static int nb_workstation = 0; static s_route_KCCFLN05_t *routing_table = NULL; #define ROUTE(i,j) routing_table[(i)+(j)*nb_workstation] +static network_link_KCCFLN05_t loopback = NULL; +static xbt_dict_t parallel_task_network_link_set = NULL; +//added to work with GTNETS +static xbt_dict_t router_set = NULL; -/**************************************/ -/************* CPU object *************/ -/**************************************/ - -/************ workstation creation *********/ -static void workstation_free(void *workstation) -{ - free(((workstation_KCCFLN05_t)workstation)->name); - xbt_dynar_free(&(((workstation_KCCFLN05_t)workstation)->incomming_communications)); - xbt_dynar_free(&(((workstation_KCCFLN05_t)workstation)->outgoing_communications)); - free(workstation); -} - -static workstation_KCCFLN05_t workstation_new(const char *name, - double power_scale, - double power_initial, - tmgr_trace_t power_trace, - e_surf_cpu_state_t state_initial, - tmgr_trace_t state_trace, - double interference_send, - double interference_recv, - double interference_send_recv, - double max_outgoing_rate) -{ - workstation_KCCFLN05_t workstation = xbt_new0(s_workstation_KCCFLN05_t, 1); - - workstation->resource = (surf_resource_t) surf_workstation_resource; - workstation->name = xbt_strdup(name); - workstation->id = nb_workstation++; - - workstation->power_scale = power_scale; - xbt_assert0(workstation->power_scale>0,"Power has to be >0"); +/*xbt_dict_t network_link_set = NULL;*/ - workstation->power_current = power_initial; - if (power_trace) - workstation->power_event = - tmgr_history_add_trace(history, power_trace, 0.0, 0, workstation); - - workstation->state_current = state_initial; - if (state_trace) - workstation->state_event = - tmgr_history_add_trace(history, state_trace, 0.0, 0, workstation); - - workstation->interference_send=interference_send; - workstation->interference_recv=interference_recv; - workstation->interference_send_recv=interference_send_recv; - - workstation->constraint = - lmm_constraint_new(maxmin_system_cpu_KCCFLN05, workstation, - workstation->power_current * workstation->power_scale); - if(max_outgoing_rate>0) - workstation->bus= - lmm_constraint_new(maxmin_system_cpu_KCCFLN05, workstation, - max_outgoing_rate); - workstation->incomming_communications = - xbt_dynar_new(sizeof(surf_action_network_KCCFLN05_t),NULL); - workstation->outgoing_communications = - xbt_dynar_new(sizeof(surf_action_network_KCCFLN05_t),NULL); - - xbt_dict_set(workstation_set, name, workstation, workstation_free); - - return workstation; -} - -static void parse_workstation(void) +/* convenient function */ +static void __update_cpu_usage(cpu_KCCFLN05_t cpu) { - double power_scale = 0.0; - double power_initial = 0.0; - tmgr_trace_t power_trace = NULL; - e_surf_cpu_state_t state_initial = SURF_CPU_OFF; - tmgr_trace_t state_trace = NULL; - double interference_send = 0.0; - double interference_recv = 0.0; - double interference_send_recv = 0.0; - double max_outgoing_rate = -1.0; - - surf_parse_get_double(&power_scale,A_cpu_power); - surf_parse_get_double(&power_initial,A_cpu_availability); - surf_parse_get_trace(&power_trace,A_cpu_availability_file); - - xbt_assert0((A_cpu_state==A_cpu_state_ON)|| - (A_cpu_state==A_cpu_state_OFF), - "Invalid state") - if (A_cpu_state==A_cpu_state_ON) state_initial = SURF_CPU_ON; - if (A_cpu_state==A_cpu_state_OFF) state_initial = SURF_CPU_OFF; - surf_parse_get_trace(&state_trace,A_cpu_state_file); - - surf_parse_get_double(&interference_send,A_cpu_interference_send); - surf_parse_get_double(&interference_recv,A_cpu_interference_recv); - surf_parse_get_double(&interference_send_recv,A_cpu_interference_send_recv); - surf_parse_get_double(&max_outgoing_rate,A_cpu_max_outgoing_rate); - - workstation_new(A_cpu_name, power_scale, power_initial, power_trace, state_initial, - state_trace, interference_send, interference_recv, - interference_send_recv, max_outgoing_rate); + int cpt; + surf_action_workstation_KCCFLN05_t action = NULL; + if ((!xbt_dynar_length(cpu->incomming_communications)) && + (!xbt_dynar_length(cpu->outgoing_communications))) { + /* No communications */ + lmm_update_constraint_bound(maxmin_system, cpu->constraint, + cpu->power_current * cpu->power_scale); + } else if ((!xbt_dynar_length(cpu->incomming_communications)) + && (xbt_dynar_length(cpu->outgoing_communications))) { + /* Emission */ + lmm_update_constraint_bound(maxmin_system, cpu->constraint, + cpu->power_current * cpu->power_scale * + cpu->interference_send); + xbt_dynar_foreach(cpu->outgoing_communications, cpt, action) + lmm_elem_set_value(maxmin_system,cpu->constraint,action->variable, + cpu->power_current * cpu->power_scale * + ROUTE(action->src->id, action->dst->id).impact_on_src + ); + } else if ((xbt_dynar_length(cpu->incomming_communications)) && + (!xbt_dynar_length(cpu->outgoing_communications))) { + /* Reception */ + lmm_update_constraint_bound(maxmin_system, cpu->constraint, + cpu->power_current * cpu->power_scale * + cpu->interference_recv); + xbt_dynar_foreach(cpu->incomming_communications, cpt, action) + lmm_elem_set_value(maxmin_system,cpu->constraint,action->variable, + cpu->power_current * cpu->power_scale * + ROUTE(action->src->id, action->dst->id).impact_on_dst + ); + } else { + /* Emission & Reception */ + lmm_update_constraint_bound(maxmin_system, cpu->constraint, + cpu->power_current * cpu->power_scale * + cpu->interference_send_recv); + xbt_dynar_foreach(cpu->outgoing_communications, cpt, action) + lmm_elem_set_value(maxmin_system,cpu->constraint,action->variable, + cpu->power_current * cpu->power_scale * + ROUTE(action->src->id, action->dst->id).impact_on_src_with_other_recv + ); + xbt_dynar_foreach(cpu->incomming_communications, cpt, action) + lmm_elem_set_value(maxmin_system,cpu->constraint,action->variable, + cpu->power_current * cpu->power_scale * + ROUTE(action->src->id, action->dst->id).impact_on_dst_with_other_send + ); + } } -/*********** resource management ***********/ +/**************************************/ +/******* Resource Public **********/ +/**************************************/ static void *name_service(const char *name) { - void *workstation = NULL; - - xbt_dict_get(workstation_set, name, &workstation); - - return workstation; -} - -static const char *get_resource_name(void *resource_id) -{ - return ((workstation_KCCFLN05_t) resource_id)->name; -} + xbt_ex_t e; + void *res=NULL; -static int cpu_used(void *resource_id) -{ - return lmm_constraint_used(maxmin_system_cpu_KCCFLN05, - ((workstation_KCCFLN05_t) resource_id)->constraint); -} -static int link_used(void *resource_id) -{ - return lmm_constraint_used(maxmin_system_network_KCCFLN05, - ((network_link_KCCFLN05_t) resource_id)->constraint); -} + + TRY { + res = xbt_dict_get_or_null(workstation_set, name); + } CATCH(e) { + WARN1("Host '%s' not found, verifing if it is a router", name); + res = NULL; + } -static e_surf_cpu_state_t get_state(void *cpu) -{ - return ((workstation_KCCFLN05_t) cpu)->state_current; -} -static void update_cpu_KCCFLN05_state(void *id, - tmgr_trace_event_t event_type, - double value) -{ - workstation_KCCFLN05_t cpu = id; - - if (event_type == cpu->power_event) { - cpu->power_current = value; - /*** The bound is updated in share_cpu_KCCFLN05_resources ***/ - /* lmm_update_constraint_bound(maxmin_system_cpu_KCCFLN05, cpu->constraint, */ - /* cpu->power_current * cpu->power_scale); */ - } else if (event_type == cpu->state_event) { - if (value > 0) - cpu->state_current = SURF_CPU_ON; - else - cpu->state_current = SURF_CPU_OFF; - } else { - CRITICAL0("Unknown event ! \n"); - xbt_abort(); + if(res == NULL){ + TRY { + res = xbt_dict_get_or_null(router_set, name); + } CATCH(e) { + if (e.category != not_found_error) + RETHROW; + xbt_ex_free(e); + res = NULL; + } } - return; + return res; } -/**************************************/ -/*********** network object ***********/ -/**************************************/ - -static void create_routing_table(void) +static const char *get_resource_name(void *resource_id) { - routing_table = xbt_new0(s_route_KCCFLN05_t, nb_workstation * nb_workstation); + /* We can freely cast as a cpu_KCCFLN05_t because it has the same + prefix as network_link_KCCFLN05_t. However, only cpu_KCCFLN05_t + will theoretically be given as an argument here. */ + return ((cpu_KCCFLN05_t) resource_id)->name; } -static void network_link_free(void *nw_link) +/* action_get_state is inherited from the surf module */ + +static void action_use(surf_action_t action) { - free(((network_link_KCCFLN05_t)nw_link)->name); - free(nw_link); + action->using++; + return; } -static network_link_KCCFLN05_t network_link_new(char *name, - double bw_initial, - tmgr_trace_t bw_trace, - e_surf_network_link_state_t - state_initial, - tmgr_trace_t state_trace) +static int action_free(surf_action_t action) { - network_link_KCCFLN05_t nw_link = xbt_new0(s_network_link_KCCFLN05_t, 1); - + int cpt; + surf_action_t act = NULL; + cpu_KCCFLN05_t src = ((surf_action_workstation_KCCFLN05_t) action)->src; + cpu_KCCFLN05_t dst = ((surf_action_workstation_KCCFLN05_t) action)->dst; - nw_link->resource = (surf_resource_t) surf_network_resource; - nw_link->name = name; - nw_link->bw_current = bw_initial; - if (bw_trace) - nw_link->bw_event = - tmgr_history_add_trace(history, bw_trace, 0.0, 0, nw_link); - nw_link->state_current = state_initial; - if (state_trace) - nw_link->state_event = - tmgr_history_add_trace(history, state_trace, 0.0, 0, nw_link); + action->using--; + if (!action->using) { + xbt_swag_remove(action, action->state_set); + if (((surf_action_workstation_KCCFLN05_t) action)->variable) + lmm_variable_free(maxmin_system, + ((surf_action_workstation_KCCFLN05_t) action)-> + variable); + if(src) + xbt_dynar_foreach(src->outgoing_communications, cpt, act) + if (act == action) { + xbt_dynar_remove_at(src->outgoing_communications, cpt, &act); + break; + } - nw_link->constraint = - lmm_constraint_new(maxmin_system_network_KCCFLN05, nw_link, nw_link->bw_current); + if(dst) + xbt_dynar_foreach(dst->incomming_communications, cpt, act) + if (act == action) { + xbt_dynar_remove_at(dst->incomming_communications, cpt, &act); + break; + } - xbt_dict_set(network_link_set, name, nw_link, network_link_free); + if(src && (!xbt_dynar_length(src->outgoing_communications))) + __update_cpu_usage(src); + if(dst && (!xbt_dynar_length(dst->incomming_communications))) + __update_cpu_usage(dst); - return nw_link; + free(action); + return 1; + } + return 0; } -static void parse_network_link(void) +static void action_cancel(surf_action_t action) { - char *name; - double bw_initial; - tmgr_trace_t bw_trace; - e_surf_network_link_state_t state_initial = SURF_NETWORK_LINK_ON; - tmgr_trace_t state_trace; - - name = xbt_strdup(A_network_link_name); - surf_parse_get_double(&bw_initial,A_network_link_bandwidth); - surf_parse_get_trace(&bw_trace, A_network_link_bandwidth_file); - - xbt_assert0((A_network_link_state==A_network_link_state_ON)|| - (A_network_link_state==A_network_link_state_OFF), - "Invalid state") - if (A_network_link_state==A_network_link_state_ON) - state_initial = SURF_NETWORK_LINK_ON; - if (A_network_link_state==A_network_link_state_OFF) - state_initial = SURF_NETWORK_LINK_OFF; - surf_parse_get_trace(&state_trace,A_network_link_state_file); - - network_link_new(name, bw_initial, bw_trace, state_initial, state_trace); + surf_action_change_state(action, SURF_ACTION_FAILED); + return; } -static void route_new(int src_id, int dst_id, char **links, int nb_link, - double impact_on_src, double impact_on_dst, - double impact_on_src_with_other_recv, - double impact_on_dst_with_other_send) +static void action_recycle(surf_action_t action) { - network_link_KCCFLN05_t *link_list = NULL; - int i; - route_KCCFLN05_t route = &(ROUTE(src_id,dst_id)); - - route->size= nb_link; - link_list = route->links = xbt_new0(network_link_KCCFLN05_t, nb_link); - for (i = 0; i < nb_link; i++) { - xbt_dict_get(network_link_set, links[i], (void *) &(link_list[i])); - free(links[i]); - } - free(links); - route->impact_on_src=impact_on_src; - route->impact_on_dst=impact_on_src; - route->impact_on_src_with_other_recv=impact_on_src_with_other_recv; - route->impact_on_dst_with_other_send=impact_on_dst_with_other_send; + DIE_IMPOSSIBLE; + return; } -static int nb_link = 0; -static char **link_name = NULL; -static int src_id = -1; -static int dst_id = -1; -static double impact_on_src; -static double impact_on_dst; -static double impact_on_src_with_other_recv; -static double impact_on_dst_with_other_send; +/* action_change_state is inherited from the surf module */ +/* action_set_data is inherited from the surf module */ -static void parse_route_set_endpoints(void) +static void action_suspend(surf_action_t action) { - src_id = ((workstation_KCCFLN05_t) name_service(A_route_src))->id; - dst_id = ((workstation_KCCFLN05_t) name_service(A_route_dst))->id; - surf_parse_get_double(&impact_on_src,A_route_impact_on_src); - surf_parse_get_double(&impact_on_dst,A_route_impact_on_dst); - surf_parse_get_double(&impact_on_src_with_other_recv,A_route_impact_on_src_with_other_recv); - surf_parse_get_double(&impact_on_dst_with_other_send,A_route_impact_on_dst_with_other_send); - - nb_link = 0; - link_name = NULL; + XBT_IN1("(%p))",action); + if(((surf_action_workstation_KCCFLN05_t) action)->suspended != 2) { + ((surf_action_workstation_KCCFLN05_t) action)->suspended = 1; + lmm_update_variable_weight(maxmin_system, + ((surf_action_workstation_KCCFLN05_t) + action)->variable, 0.0); + } + XBT_OUT; } -static void parse_route_elem(void) +static void action_resume(surf_action_t action) { - nb_link++; - link_name = xbt_realloc(link_name, (nb_link) * sizeof(char *)); - link_name[(nb_link) - 1] = xbt_strdup(A_route_element_name); + XBT_IN1("(%p)",action); + if(((surf_action_workstation_KCCFLN05_t) action)->suspended !=2) { + if(((surf_action_workstation_KCCFLN05_t)action)->lat_current==0.0) + lmm_update_variable_weight(maxmin_system, + ((surf_action_workstation_KCCFLN05_t) + action)->variable, 1.0); + else + lmm_update_variable_weight(maxmin_system, + ((surf_action_workstation_KCCFLN05_t) action)->variable, + ((surf_action_workstation_KCCFLN05_t) action)->lat_current); + + ((surf_action_workstation_KCCFLN05_t) action)->suspended = 0; + } + XBT_OUT; } -static void parse_route_set_route(void) +static int action_is_suspended(surf_action_t action) { - route_new(src_id, dst_id, link_name, nb_link, impact_on_src, impact_on_dst, - impact_on_src_with_other_recv, impact_on_dst_with_other_send); + return (((surf_action_workstation_KCCFLN05_t) action)->suspended==1); } -static void parse_file(const char *file) -{ - /* Figuring out the workstations */ - surf_parse_reset_parser(); - ETag_cpu_fun=parse_workstation; - surf_parse_open(file); - xbt_assert1((!surf_parse()),"Parse error in %s",file); - surf_parse_close(); - - create_routing_table(); - - /* Figuring out the network links */ - surf_parse_reset_parser(); - ETag_network_link_fun=parse_network_link; - surf_parse_open(file); - xbt_assert1((!surf_parse()),"Parse error in %s",file); - surf_parse_close(); - - /* Building the routes */ - surf_parse_reset_parser(); - STag_route_fun=parse_route_set_endpoints; - ETag_route_element_fun=parse_route_elem; - ETag_route_fun=parse_route_set_route; - surf_parse_open(file); - xbt_assert1((!surf_parse()),"Parse error in %s",file); - surf_parse_close(); +static void action_set_max_duration(surf_action_t action, double duration) +{ /* FIXME: should inherit */ + XBT_IN2("(%p,%g)",action,duration); + action->max_duration = duration; + XBT_OUT; } -static void update_network_KCCFLN05_state(void *id, - tmgr_trace_event_t event_type, - double value) -{ - network_link_KCCFLN05_t nw_link = id; - - if (event_type == nw_link->bw_event) { - nw_link->bw_current = value; - lmm_update_constraint_bound(maxmin_system_network_KCCFLN05, nw_link->constraint, - nw_link->bw_current); - } else if (event_type == nw_link->state_event) { - if (value > 0) - nw_link->state_current = SURF_NETWORK_LINK_ON; - else - nw_link->state_current = SURF_NETWORK_LINK_OFF; - } else { - CRITICAL0("Unknown event ! \n"); - xbt_abort(); - } - return; +static void action_set_priority(surf_action_t action, double priority) +{ /* FIXME: should inherit */ + XBT_IN2("(%p,%g)",action,priority); + action->priority = priority; + XBT_OUT; } /**************************************/ -/*************** actions **************/ +/******* Resource Private **********/ /**************************************/ -/*************** network **************/ -static int action_network_KCCFLN05_free(surf_action_t action) -{ - int cpt; - surf_action_t act = NULL; - workstation_KCCFLN05_t src = ((surf_action_network_KCCFLN05_t) action)->src; - workstation_KCCFLN05_t dst = ((surf_action_network_KCCFLN05_t) action)->dst; - - action->using--; - if(!action->using) { - - xbt_swag_remove(action, action->state_set); - if(((surf_action_network_KCCFLN05_t)action)->variable) - lmm_variable_free(maxmin_system_network_KCCFLN05, - ((surf_action_network_KCCFLN05_t) action)->variable); - - xbt_dynar_foreach (src->outgoing_communications,cpt,act) { - if(act==action) { - xbt_dynar_remove_at(src->outgoing_communications, cpt, &act); - break; - } - } - - xbt_dynar_foreach (dst->incomming_communications,cpt,act) { - if(act==action) { - xbt_dynar_remove_at(dst->incomming_communications, cpt, &act); - break; - } - } - - free(action); - return 1; - } - return 0; -} -static void action_network_KCCFLN05_use(surf_action_t action) +static int resource_used(void *resource_id) { - action->using++; -} + /* We can freely cast as a network_link_KCCFLN05_t because it has + the same prefix as cpu_KCCFLN05_t */ + if(((cpu_KCCFLN05_t) resource_id)->type == SURF_WORKSTATION_RESOURCE_CPU) + return (lmm_constraint_used(maxmin_system, + ((cpu_KCCFLN05_t) resource_id)-> + constraint) || + ((((cpu_KCCFLN05_t) resource_id)->bus)? + lmm_constraint_used(maxmin_system, + ((cpu_KCCFLN05_t) resource_id)-> + bus):0)); + else + return lmm_constraint_used(maxmin_system, + ((network_link_KCCFLN05_t) resource_id)-> + constraint); -static double share_network_KCCFLN05_resources(double now) -{ - s_surf_action_network_KCCFLN05_t action; - return generic_maxmin_share_resources2(surf_network_resource->common_public-> - states.running_action_set, - xbt_swag_offset(action, variable), - maxmin_system_network_KCCFLN05); } -static void action_network_KCCFLN05_change_state(surf_action_t action, - e_surf_action_state_t state) +static double share_resources(double now) { - int cpt; - surf_action_t act = NULL; - workstation_KCCFLN05_t src = ((surf_action_network_KCCFLN05_t) action)->src; - workstation_KCCFLN05_t dst = ((surf_action_network_KCCFLN05_t) action)->dst; - -/* if((state==SURF_ACTION_DONE) || (state==SURF_ACTION_FAILED)) */ -/* if(((surf_action_network_KCCFLN05_t)action)->variable) { */ -/* lmm_variable_disable(maxmin_system_network_KCCFLN05, */ -/* ((surf_action_network_KCCFLN05_t)action)->variable); */ -/* ((surf_action_network_KCCFLN05_t)action)->variable = NULL; */ -/* } */ - - xbt_dynar_foreach (src->outgoing_communications,cpt,act) { - if(act==action) { - xbt_dynar_remove_at(src->outgoing_communications, cpt, &act); - break; + s_surf_action_workstation_KCCFLN05_t s_action; + surf_action_workstation_KCCFLN05_t action = NULL; + + xbt_swag_t running_actions = surf_workstation_resource->common_public->states.running_action_set; + double min = generic_maxmin_share_resources(running_actions, + xbt_swag_offset(s_action, variable)); + + xbt_swag_foreach(action, running_actions) { + if(action->latency>0) { + if(min<0) { + min = action->latency; + DEBUG3("Updating min (value) with %p (start %f): %f",action, + action->generic_action.start, min); + } + else if (action->latencylatency; + DEBUG3("Updating min (latency) with %p (start %f): %f",action, + action->generic_action.start, min); + } } } - xbt_dynar_foreach (dst->incomming_communications,cpt,act) { - if(act==action) { - xbt_dynar_remove_at(dst->incomming_communications, cpt, &act); - break; - } - } - surf_action_change_state(action, state); - return; + DEBUG1("min value : %f",min); + + return min; } -static void update_actions_network_KCCFLN05_state(double now, double delta) +static void update_actions_state(double now, double delta) { - surf_action_network_KCCFLN05_t action = NULL; - surf_action_network_KCCFLN05_t next_action = NULL; + double deltap = 0.0; + surf_action_workstation_KCCFLN05_t action = NULL; + surf_action_workstation_KCCFLN05_t next_action = NULL; xbt_swag_t running_actions = - surf_network_resource->common_public->states.running_action_set; - xbt_swag_t failed_actions = - surf_network_resource->common_public->states.failed_action_set; + surf_workstation_resource->common_public->states.running_action_set; xbt_swag_foreach_safe(action, next_action, running_actions) { - surf_double_update(&(action->generic_action.remains), - lmm_variable_getvalue(action->variable) * delta); + deltap = delta; + if (action->latency > 0) { + if (action->latency > deltap) { + double_update(&(action->latency), deltap); + deltap = 0.0; + } else { + double_update(&(deltap), action->latency); + action->latency = 0.0; + } + if ((action->latency == 0.0) && (action->suspended==0)) { + if((action)->lat_current==0.0) + lmm_update_variable_weight(maxmin_system,action->variable, 1.0); + else + lmm_update_variable_weight(maxmin_system, action->variable, + action->lat_current); + } + } + DEBUG3("Action (%p) : remains (%g) updated by %g.", + action, action->generic_action.remains, + lmm_variable_getvalue(action->variable) * deltap); + double_update(&(action->generic_action.remains), + lmm_variable_getvalue(action->variable) * deltap); + if (action->generic_action.max_duration != NO_MAX_DURATION) - surf_double_update(&(action->generic_action.max_duration), delta); - if ((action->generic_action.remains <= 0.0) && + double_update(&(action->generic_action.max_duration), delta); + + /* if(action->generic_action.remains<.00001) action->generic_action.remains=0; */ + + if ((action->generic_action.remains <= 0) && (lmm_get_variable_weight(action->variable)>0)) { action->generic_action.finish = surf_get_clock(); - action_network_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_DONE); + surf_action_change_state((surf_action_t) action, SURF_ACTION_DONE); } else if ((action->generic_action.max_duration != NO_MAX_DURATION) && - (action->generic_action.max_duration <= 0.0)) { + (action->generic_action.max_duration <= 0)) { action->generic_action.finish = surf_get_clock(); - action_network_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_DONE); + surf_action_change_state((surf_action_t) action, SURF_ACTION_DONE); } else { /* Need to check that none of the resource has failed */ - /* FIXME : FAILURES ARE NOT HANDLED YET */ + lmm_constraint_t cnst = NULL; + int i = 0; + void *constraint_id = NULL; + + while ((cnst = + lmm_get_cnst_from_var(maxmin_system, action->variable, + i++))) { + constraint_id = lmm_constraint_id(cnst); + if(((((network_link_KCCFLN05_t)constraint_id)->type== + SURF_WORKSTATION_RESOURCE_LINK) && + (((network_link_KCCFLN05_t)constraint_id)->state_current== + SURF_NETWORK_LINK_OFF)) || + ((((cpu_KCCFLN05_t)constraint_id)->type== + SURF_WORKSTATION_RESOURCE_CPU) && + (((cpu_KCCFLN05_t)constraint_id)->state_current== + SURF_CPU_OFF))) { + action->generic_action.finish = surf_get_clock(); + surf_action_change_state((surf_action_t) action, SURF_ACTION_FAILED); + break; + } + } } } - return; } -static surf_action_t communicate_KCCFLN05(void *src, void *dst, double size, - double rate) +static void update_resource_state(void *id, + tmgr_trace_event_t event_type, + double value) { - surf_action_network_KCCFLN05_t action = NULL; - workstation_KCCFLN05_t card_src = src; - workstation_KCCFLN05_t card_dst = dst; - route_KCCFLN05_t route = &ROUTE(card_src->id, card_dst->id); - int i; - - action = xbt_new0(s_surf_action_network_KCCFLN05_t, 1); - - action->generic_action.using = 1; - action->generic_action.cost = size; - action->generic_action.remains = size; - action->generic_action.max_duration = NO_MAX_DURATION; - action->generic_action.start = -1.0; - action->generic_action.finish = -1.0; - action->generic_action.resource_type = - (surf_resource_t) surf_network_resource; - - action->generic_action.state_set = - surf_network_resource->common_public->states.running_action_set; - - xbt_swag_insert(action, action->generic_action.state_set); - - if(rate>0) - action->variable = lmm_variable_new(maxmin_system_network_KCCFLN05, action, 1.0, rate, - route->size+1); - else - action->variable = lmm_variable_new(maxmin_system_network_KCCFLN05, action, 1.0, -1.0, - route->size+1); + cpu_KCCFLN05_t cpu = id; + network_link_KCCFLN05_t nw_link = id ; + + if(nw_link->type == SURF_WORKSTATION_RESOURCE_LINK) { + if (event_type == nw_link->bw_event) { + nw_link->bw_current = value; + lmm_update_constraint_bound(maxmin_system, nw_link->constraint, + nw_link->bw_current); + } else if (event_type == nw_link->lat_event) { + double delta = value - nw_link->lat_current; + lmm_variable_t var = NULL; + surf_action_workstation_KCCFLN05_t action = NULL; + + nw_link->lat_current = value; + while (lmm_get_var_from_cnst(maxmin_system, nw_link->constraint, &var)) { + action = lmm_variable_id(var); + action->lat_current += delta; + if(action->rate<0) + lmm_update_variable_bound(maxmin_system, action->variable, + SG_TCP_CTE_GAMMA / (2.0 * action->lat_current)); + else + lmm_update_variable_bound(maxmin_system, action->variable, + min(action->rate,SG_TCP_CTE_GAMMA / (2.0 * action->lat_current))); + if(action->suspended==0) + lmm_update_variable_weight(maxmin_system, action->variable, + action->lat_current); + lmm_update_variable_latency(maxmin_system, action->variable, delta); + - for (i = 0; i < route->size; i++) - lmm_expand(maxmin_system_network_KCCFLN05, route->links[i]->constraint, - action->variable, 1.0); + } + } else if (event_type == nw_link->state_event) { + if (value > 0) + nw_link->state_current = SURF_NETWORK_LINK_ON; + else + nw_link->state_current = SURF_NETWORK_LINK_OFF; + } else { + CRITICAL0("Unknown event ! \n"); + xbt_abort(); + } + return; + } else if(cpu->type == SURF_WORKSTATION_RESOURCE_CPU) { + if (event_type == cpu->power_event) { + cpu->power_current = value; + __update_cpu_usage(cpu); + } else if (event_type == cpu->state_event) { + if (value > 0) + cpu->state_current = SURF_CPU_ON; + else + cpu->state_current = SURF_CPU_OFF; + } else { + CRITICAL0("Unknown event ! \n"); + xbt_abort(); + } + return; + } else { + DIE_IMPOSSIBLE; + } + return; +} - if(card_src->bus) - lmm_expand(maxmin_system_network_KCCFLN05, card_src->bus, - action->variable, 1.0); +static void finalize(void) +{ + int i,j; - action->src=src; - action->dst=dst; + xbt_dict_free(&network_link_set); + xbt_dict_free(&workstation_set); + xbt_dict_free(&router_set); + if (parallel_task_network_link_set != NULL) { + xbt_dict_free(¶llel_task_network_link_set); + } + xbt_swag_free(surf_workstation_resource->common_public->states. + ready_action_set); + xbt_swag_free(surf_workstation_resource->common_public->states. + running_action_set); + xbt_swag_free(surf_workstation_resource->common_public->states. + failed_action_set); + xbt_swag_free(surf_workstation_resource->common_public->states. + done_action_set); - xbt_dynar_push(card_src->outgoing_communications,&action); - xbt_dynar_push(card_dst->incomming_communications,&action); + free(surf_workstation_resource->common_public); + free(surf_workstation_resource->common_private); + free(surf_workstation_resource->extension_public); - return (surf_action_t) action; -} + free(surf_workstation_resource); + surf_workstation_resource = NULL; -static surf_action_t execute_parallel_task_KCCFLN05 (int workstation_nb, - void **workstation_list, - double *computation_amount, - double *communication_amount, - double amount, - double rate) -{ - DIE_IMPOSSIBLE; - return NULL; -} + for (i = 0; i < nb_workstation; i++) + for (j = 0; j < nb_workstation; j++) + free(ROUTE(i, j).links); + free(routing_table); + routing_table = NULL; + nb_workstation = 0; -static void network_KCCFLN05_action_suspend(surf_action_t action) -{ - lmm_update_variable_weight(maxmin_system_network_KCCFLN05, - ((surf_action_network_KCCFLN05_t) action)->variable, 0.0); + if (maxmin_system) { + lmm_system_free(maxmin_system); + maxmin_system = NULL; + } } -static void network_KCCFLN05_action_resume(surf_action_t action) -{ - lmm_update_variable_weight(maxmin_system_network_KCCFLN05, - ((surf_action_network_KCCFLN05_t) action)->variable, 1.0); -} +/**************************************/ +/******* Resource Private **********/ +/**************************************/ -static int network_KCCFLN05_action_is_suspended(surf_action_t action) +static surf_action_t execute(void *cpu, double size) { - return (lmm_get_variable_weight(((surf_action_network_KCCFLN05_t) action)->variable) == 0.0); -} + surf_action_workstation_KCCFLN05_t action = NULL; + cpu_KCCFLN05_t CPU = cpu; -static void network_KCCFLN05_action_set_max_duration(surf_action_t action, double duration) -{ - action->max_duration = duration; -} + XBT_IN2("(%s,%g)",CPU->name,size); + action = xbt_new0(s_surf_action_workstation_KCCFLN05_t, 1); -/***************** CPU ****************/ -static int action_cpu_KCCFLN05_free(surf_action_t action) -{ - action->using--; - if(!action->using) { - xbt_swag_remove(action, action->state_set); - if(((surf_action_cpu_KCCFLN05_t)action)->variable) - lmm_variable_free(maxmin_system_cpu_KCCFLN05, ((surf_action_cpu_KCCFLN05_t)action)->variable); - free(action); - return 1; - } - return 0; -} + action->generic_action.using = 1; + action->generic_action.cost = size; + action->generic_action.remains = size; + action->generic_action.priority = 1.0; + action->generic_action.max_duration = NO_MAX_DURATION; + action->generic_action.start = surf_get_clock(); + action->generic_action.finish = -1.0; + action->generic_action.resource_type = + (surf_resource_t) surf_workstation_resource; + action->suspended = 0; -static void action_cpu_KCCFLN05_use(surf_action_t action) -{ - action->using++; -} + if (CPU->state_current == SURF_CPU_ON) + action->generic_action.state_set = + surf_workstation_resource->common_public->states.running_action_set; + else + action->generic_action.state_set = + surf_workstation_resource->common_public->states.failed_action_set; + xbt_swag_insert(action, action->generic_action.state_set); -static void action_cpu_KCCFLN05_change_state(surf_action_t action, - e_surf_action_state_t state) -{ -/* if((state==SURF_ACTION_DONE) || (state==SURF_ACTION_FAILED)) */ -/* if(((surf_action_cpu_KCCFLN05_t)action)->variable) { */ -/* lmm_variable_disable(maxmin_system_cpu_KCCFLN05, */ -/* ((surf_action_cpu_KCCFLN05_t)action)->variable); */ -/* ((surf_action_cpu_KCCFLN05_t)action)->variable = NULL; */ -/* } */ - - surf_action_change_state(action, state); - return; + action->variable = lmm_variable_new(maxmin_system, action, + action->generic_action.priority, -1.0, 1); + lmm_expand(maxmin_system, CPU->constraint, action->variable, + 1.0); + XBT_OUT; + return (surf_action_t) action; } -static double share_cpu_KCCFLN05_resources(double now) +static surf_action_t action_sleep(void *cpu, double duration) { - s_surf_action_cpu_KCCFLN05_t s_cpu_action; - lmm_constraint_t cnst = NULL; - workstation_KCCFLN05_t workstation = NULL; - double W=0.0; - double scale=0.0; - int cpt; - surf_action_network_KCCFLN05_t action; + surf_action_workstation_KCCFLN05_t action = NULL; - if(surf_get_clock()>=475.895) - { - W=0.0; - } + XBT_IN2("(%s,%g)",((cpu_KCCFLN05_t)cpu)->name,duration); - for(cnst = lmm_get_first_active_constraint(maxmin_system_cpu_KCCFLN05); - cnst; - cnst= lmm_get_next_active_constraint(maxmin_system_cpu_KCCFLN05, cnst)) - { - workstation = lmm_constraint_id(cnst); - W=workstation->power_current * workstation->power_scale; - - if((!xbt_dynar_length(workstation->incomming_communications)) && - (!xbt_dynar_length(workstation->outgoing_communications))) { - scale = 1.0; - } else if((!xbt_dynar_length(workstation->incomming_communications)) && - (xbt_dynar_length(workstation->outgoing_communications))) { - scale = workstation->interference_send; - xbt_dynar_foreach (workstation->outgoing_communications,cpt,action) { -/* VOIRD(action->src->id); */ -/* VOIRD(action->dst->id); */ -/* VOIRP(&ROUTE(action->src->id,action->dst->id)); */ -/* VOIRG(ROUTE(action->src->id,action->dst->id).impact_on_src); */ - scale -= ROUTE(action->src->id,action->dst->id).impact_on_src * - lmm_variable_getvalue(action->variable); - } - if(scale<0.0) scale=0.0; - xbt_assert0(scale>=0.0,"Negative interference !"); - } else if((xbt_dynar_length(workstation->incomming_communications)) && - (!xbt_dynar_length(workstation->outgoing_communications))) { - scale = workstation->interference_recv; - xbt_dynar_foreach (workstation->incomming_communications,cpt,action) { - scale -= ROUTE(action->src->id,action->dst->id).impact_on_dst * - lmm_variable_getvalue(action->variable); - } - if(scale<0.0) scale=0.0; - xbt_assert0(scale>=0.0,"Negative interference !"); - } else { - scale = workstation->interference_send_recv; - xbt_dynar_foreach (workstation->outgoing_communications,cpt,action) { - scale -= ROUTE(action->src->id,action->dst->id).impact_on_src_with_other_recv * - lmm_variable_getvalue(action->variable); - } - xbt_dynar_foreach (workstation->incomming_communications,cpt,action) { - scale -= ROUTE(action->src->id,action->dst->id).impact_on_dst_with_other_send * - lmm_variable_getvalue(action->variable); - } - if(scale<0.0) scale=0.1; - xbt_assert0(scale>=0.0,"Negative interference !"); - } - lmm_update_constraint_bound(maxmin_system_cpu_KCCFLN05,workstation->constraint, - W*scale); - } + action = (surf_action_workstation_KCCFLN05_t) execute(cpu, 1.0); + action->generic_action.max_duration = duration; + action->suspended = 2; + lmm_update_variable_weight(maxmin_system, action->variable, 0.0); - return generic_maxmin_share_resources2(surf_cpu_resource->common_public-> - states.running_action_set, - xbt_swag_offset(s_cpu_action, variable), - maxmin_system_cpu_KCCFLN05); + XBT_OUT; + return (surf_action_t) action; } -static void update_actions_cpu_KCCFLN05_state(double now, double delta) +static e_surf_cpu_state_t resource_get_state(void *cpu) { - surf_action_cpu_KCCFLN05_t action = NULL; - surf_action_cpu_KCCFLN05_t next_action = NULL; - xbt_swag_t running_actions = - surf_cpu_resource->common_public->states.running_action_set; - xbt_swag_t failed_actions = - surf_cpu_resource->common_public->states.failed_action_set; - - xbt_swag_foreach_safe(action, next_action, running_actions) { - surf_double_update(&(action->generic_action.remains), - lmm_variable_getvalue(action->variable) * delta); - if (action->generic_action.max_duration != NO_MAX_DURATION) - action->generic_action.max_duration -= delta; - if ((action->generic_action.remains <= 0) && - (lmm_get_variable_weight(action->variable)>0)) { - action->generic_action.finish = surf_get_clock(); - action_cpu_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_DONE); - } else if ((action->generic_action.max_duration != NO_MAX_DURATION) && - (action->generic_action.max_duration <= 0)) { - action->generic_action.finish = surf_get_clock(); - action_cpu_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_DONE); - } else { /* Need to check that none of the resource has failed */ - lmm_constraint_t cnst = NULL; - int i = 0; - workstation_KCCFLN05_t cpu = NULL; + return ((cpu_KCCFLN05_t) cpu)->state_current; +} - while ((cnst = - lmm_get_cnst_from_var(maxmin_system_cpu_KCCFLN05, action->variable, - i++))) { - cpu = lmm_constraint_id(cnst); - if (cpu->state_current == SURF_CPU_OFF) { - action->generic_action.finish = surf_get_clock(); - action_cpu_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_FAILED); - break; - } - } - } - } +static double get_speed(void *cpu, double load) +{ + return load*(((cpu_KCCFLN05_t) cpu)->power_scale); +} - return; +static double get_available_speed(void *cpu) +{ + return ((cpu_KCCFLN05_t) cpu)->power_current; } -static surf_action_t execute_KCCFLN05(void *cpu, double size) + +static surf_action_t communicate(void *src, void *dst, double size, double rate) { - surf_action_cpu_KCCFLN05_t action = NULL; - workstation_KCCFLN05_t CPU = cpu; + surf_action_workstation_KCCFLN05_t action = NULL; + cpu_KCCFLN05_t card_src = src; + cpu_KCCFLN05_t card_dst = dst; + route_KCCFLN05_t route = &(ROUTE(card_src->id, card_dst->id)); + int route_size = route->size; + int i; + + XBT_IN4("(%s,%s,%g,%g)",card_src->name,card_dst->name,size,rate); + xbt_assert2(route_size,"You're trying to send data from %s to %s but there is no connexion between these two cards.", card_src->name, card_dst->name); - action = xbt_new0(s_surf_action_cpu_KCCFLN05_t, 1); + action = xbt_new0(s_surf_action_workstation_KCCFLN05_t, 1); action->generic_action.using = 1; action->generic_action.cost = size; @@ -706,323 +543,518 @@ static surf_action_t execute_KCCFLN05(void *cpu, double size) action->generic_action.max_duration = NO_MAX_DURATION; action->generic_action.start = surf_get_clock(); action->generic_action.finish = -1.0; + action->src = src; + action->dst = dst; action->generic_action.resource_type = - (surf_resource_t) surf_cpu_resource; + (surf_resource_t) surf_workstation_resource; + action->suspended = 0; /* Should be useless because of the + calloc but it seems to help valgrind... */ + action->generic_action.state_set = + surf_workstation_resource->common_public->states.running_action_set; + + xbt_dynar_push(card_src->outgoing_communications, &action); + xbt_dynar_push(card_dst->incomming_communications, &action); - if (CPU->state_current == SURF_CPU_ON) - action->generic_action.state_set = - surf_cpu_resource->common_public->states.running_action_set; - else - action->generic_action.state_set = - surf_cpu_resource->common_public->states.failed_action_set; xbt_swag_insert(action, action->generic_action.state_set); + action->rate = rate; + + action->latency = 0.0; + for (i = 0; i < route_size; i++) + action->latency += route->links[i]->lat_current; + action->lat_current = action->latency; + + if(action->latency>0) + action->variable = lmm_variable_new(maxmin_system, action, 0.0, -1.0, + route_size+4); /* +1 for the src bus + +1 for the dst bus + +1 for the src cpu + +1 for the dst cpu */ + else + action->variable = lmm_variable_new(maxmin_system, action, 1.0, -1.0, + route_size+4); - action->variable = lmm_variable_new(maxmin_system_cpu_KCCFLN05, action, 1.0, -1.0, 1); - lmm_expand(maxmin_system_cpu_KCCFLN05, CPU->constraint, action->variable, - 1.0); + if(action->rate<0) { + if(action->lat_current>0) + lmm_update_variable_bound(maxmin_system, action->variable, + SG_TCP_CTE_GAMMA / (2.0 * action->lat_current)); + else + lmm_update_variable_bound(maxmin_system, action->variable, -1.0); + } else { + if(action->lat_current>0) + lmm_update_variable_bound(maxmin_system, action->variable, + min(action->rate,SG_TCP_CTE_GAMMA / (2.0 * action->lat_current))); + else + lmm_update_variable_bound(maxmin_system, action->variable, action->rate); + } + lmm_update_variable_latency(maxmin_system, action->variable, action->latency); + + for (i = 0; i < route_size; i++) + lmm_expand(maxmin_system, route->links[i]->constraint, action->variable, 1.0); + if (card_src->bus) + lmm_expand(maxmin_system, card_src->bus, action->variable, 1.0); + if (card_dst->bus) + lmm_expand(maxmin_system, card_dst->bus, action->variable, 1.0); + lmm_expand(maxmin_system, card_src->constraint, action->variable, 0.0); + lmm_expand(maxmin_system, card_dst->constraint, action->variable, 0.0); + + XBT_OUT; return (surf_action_t) action; } -static void cpu_KCCFLN05_action_suspend(surf_action_t action) +static surf_action_t execute_parallel_task(int workstation_nb, + void **workstation_list, + double *computation_amount, + double *communication_amount, + double amount, + double rate) { - lmm_update_variable_weight(maxmin_system_cpu_KCCFLN05, - ((surf_action_cpu_KCCFLN05_t) action)->variable, 0.0); + surf_action_workstation_KCCFLN05_t action = NULL; + int i, j, k; + int nb_link = 0; + int nb_host = 0; + + if (parallel_task_network_link_set == NULL) { + parallel_task_network_link_set = xbt_dict_new_ext(workstation_nb * workstation_nb * 10); + } + + /* Compute the number of affected resources... */ + for(i=0; i< workstation_nb; i++) { + for(j=0; j< workstation_nb; j++) { + cpu_KCCFLN05_t card_src = workstation_list[i]; + cpu_KCCFLN05_t card_dst = workstation_list[j]; + int route_size = ROUTE(card_src->id, card_dst->id).size; + network_link_KCCFLN05_t *route = ROUTE(card_src->id, card_dst->id).links; + + if(communication_amount[i*workstation_nb+j]>0) + for(k=0; k< route_size; k++) { + xbt_dict_set(parallel_task_network_link_set, route[k]->name, route[k], NULL); + } + } + } + nb_link = xbt_dict_length(parallel_task_network_link_set); + xbt_dict_reset(parallel_task_network_link_set); + + + for (i = 0; i0) nb_host++; + + + if(nb_link + nb_host == 0) /* was workstation_nb... */ + return NULL; + + action = xbt_new0(s_surf_action_workstation_KCCFLN05_t, 1); + DEBUG3("Creating a parallel task (%p) with %d cpus and %d links.", + action, nb_host, nb_link); + action->generic_action.using = 1; + action->generic_action.cost = amount; + action->generic_action.remains = amount; + action->generic_action.max_duration = NO_MAX_DURATION; + action->generic_action.start = -1.0; + action->generic_action.finish = -1.0; + action->generic_action.resource_type = + (surf_resource_t) surf_workstation_resource; + action->suspended = 0; /* Should be useless because of the + calloc but it seems to help valgrind... */ + action->generic_action.state_set = + surf_workstation_resource->common_public->states.running_action_set; + + xbt_swag_insert(action, action->generic_action.state_set); + action->rate = rate; + + if(action->rate>0) + action->variable = lmm_variable_new(maxmin_system, action, 1.0, -1.0, + nb_host + nb_link); + else + action->variable = lmm_variable_new(maxmin_system, action, 1.0, action->rate, + nb_host + nb_link); + + for (i = 0; i0) + lmm_expand(maxmin_system, ((cpu_KCCFLN05_t) workstation_list[i])->constraint, + action->variable, computation_amount[i]); + + for (i=0; iid, card_dst->id).size; + network_link_KCCFLN05_t *route = ROUTE(card_src->id, card_dst->id).links; + + for(k=0; k< route_size; k++) { + if(communication_amount[i*workstation_nb+j]>0) { + lmm_expand_add(maxmin_system, route[k]->constraint, + action->variable, communication_amount[i*workstation_nb+j]); + } + } + } + } + + return (surf_action_t) action; } -static void cpu_KCCFLN05_action_resume(surf_action_t action) -{ - lmm_update_variable_weight(maxmin_system_cpu_KCCFLN05, - ((surf_action_cpu_KCCFLN05_t) action)->variable, 1.0); +/* returns an array of network_link_KCCFLN05_t */ +static const void** get_route(void *src, void *dst) { + cpu_KCCFLN05_t card_src = src; + cpu_KCCFLN05_t card_dst = dst; + route_KCCFLN05_t route = &(ROUTE(card_src->id, card_dst->id)); + + return (const void**) route->links; } -static int cpu_KCCFLN05_action_is_suspended(surf_action_t action) -{ - return (lmm_get_variable_weight(((surf_action_cpu_KCCFLN05_t) action)->variable) == 0.0); +static int get_route_size(void *src, void *dst) { + cpu_KCCFLN05_t card_src = src; + cpu_KCCFLN05_t card_dst = dst; + route_KCCFLN05_t route = &(ROUTE(card_src->id, card_dst->id)); + return route->size; } -static void cpu_KCCFLN05_action_set_max_duration(surf_action_t action, double duration) -{ - action->max_duration = duration; +static const char *get_link_name(const void *link) { + return ((network_link_KCCFLN05_t) link)->name; } -/************* workstation ************/ -static void action_change_state(surf_action_t action, - e_surf_action_state_t state) -{ - if(action->resource_type==(surf_resource_t)surf_network_resource) - surf_network_resource->common_public->action_change_state(action,state); - else if(action->resource_type==(surf_resource_t)surf_cpu_resource) - surf_cpu_resource->common_public->action_change_state(action,state); - else DIE_IMPOSSIBLE; - return; +static double get_link_bandwidth(const void *link) { + return ((network_link_KCCFLN05_t) link)->bw_current; } -static int action_free(surf_action_t action) -{ - if(action->resource_type==(surf_resource_t)surf_network_resource) - return surf_network_resource->common_public->action_free(action); - else if(action->resource_type==(surf_resource_t)surf_cpu_resource) - return surf_cpu_resource->common_public->action_free(action); - else DIE_IMPOSSIBLE; - return 1; +static double get_link_latency(const void *link) { + return ((network_link_KCCFLN05_t) link)->lat_current; } -static void action_use(surf_action_t action) +/**************************************/ +/*** Resource Creation & Destruction **/ +/**************************************/ + + +static void router_free(void *router) { - if(action->resource_type==(surf_resource_t)surf_network_resource) - surf_network_resource->common_public->action_use(action); - else if(action->resource_type==(surf_resource_t)surf_cpu_resource) - surf_cpu_resource->common_public->action_use(action); - else DIE_IMPOSSIBLE; - return; + free( ((router_KCCFLN05_t) router)->name ); } -static int resource_used(void *resource_id) +static void router_new(const char *name) { - xbt_assert0(0, "Workstation is a virtual resource. I should not be there!"); - return 0; + static unsigned int nb_routers = 0; + + INFO1("Creating a router %s", name); + + cpu_KCCFLN05_t router; + router = xbt_new0(s_cpu_KCCFLN05_t, 1); + + router->name = xbt_strdup(name); + router->id = nb_routers++; + xbt_dict_set(router_set, name, router, router_free); } -static double share_resources(double now) +static void parse_route_set_routers(void) { - return -1.0; + //add a dumb router just to be GTNETS compatible + router_new(A_surfxml_router_name); } -static void update_actions_state(double now, double delta) +static void cpu_free(void *cpu) { - return; + free(((cpu_KCCFLN05_t) cpu)->name); + xbt_dynar_free(&(((cpu_KCCFLN05_t) cpu)->incomming_communications)); + xbt_dynar_free(&(((cpu_KCCFLN05_t) cpu)->outgoing_communications)); + free(cpu); } -static void update_resource_state(void *id, - tmgr_trace_event_t event_type, - double value) +static cpu_KCCFLN05_t cpu_new(const char *name, double power_scale, + double power_initial, + tmgr_trace_t power_trace, + e_surf_cpu_state_t state_initial, + tmgr_trace_t state_trace, + double interference_send, + double interference_recv, + double interference_send_recv, + double max_outgoing_rate) { - xbt_assert0(0, "Workstation is a virtual resource. I should not be there!"); - return; + cpu_KCCFLN05_t cpu = xbt_new0(s_cpu_KCCFLN05_t, 1); + + cpu->resource = (surf_resource_t) surf_workstation_resource; + cpu->type = SURF_WORKSTATION_RESOURCE_CPU; + cpu->name = xbt_strdup(name); + cpu->id = nb_workstation++; + + cpu->power_scale = power_scale; + xbt_assert0(cpu->power_scale > 0, "Power has to be >0"); + + cpu->power_current = power_initial; + if (power_trace) + cpu->power_event = + tmgr_history_add_trace(history, power_trace, 0.0, 0, cpu); + + cpu->state_current = state_initial; + if (state_trace) + cpu->state_event = + tmgr_history_add_trace(history, state_trace, 0.0, 0, cpu); + + cpu->interference_send = interference_send; + cpu->interference_recv = interference_recv; + cpu->interference_send_recv = interference_send_recv; + + cpu->constraint = + lmm_constraint_new(maxmin_system, cpu, + cpu->power_current * cpu->power_scale); + if (max_outgoing_rate > 0) + cpu->bus = lmm_constraint_new(maxmin_system, cpu, max_outgoing_rate); + + cpu->incomming_communications = + xbt_dynar_new(sizeof(surf_action_workstation_KCCFLN05_t), NULL); + cpu->outgoing_communications = + xbt_dynar_new(sizeof(surf_action_workstation_KCCFLN05_t), NULL); + + xbt_dict_set(workstation_set, name, cpu, cpu_free); + + return cpu; } -static void action_suspend(surf_action_t action) +static void parse_cpu(void) { - if(action->resource_type==(surf_resource_t)surf_network_resource) - surf_network_resource->common_public->suspend(action); - else if(action->resource_type==(surf_resource_t)surf_cpu_resource) - surf_cpu_resource->common_public->suspend(action); - else DIE_IMPOSSIBLE; + double power_scale = 0.0; + double power_initial = 0.0; + tmgr_trace_t power_trace = NULL; + e_surf_cpu_state_t state_initial = SURF_CPU_OFF; + tmgr_trace_t state_trace = NULL; + double interference_send = 0.0; + double interference_recv = 0.0; + double interference_send_recv = 0.0; + double max_outgoing_rate = -1.0; + + surf_parse_get_double(&power_scale, A_surfxml_cpu_power); + surf_parse_get_double(&power_initial, A_surfxml_cpu_availability); + surf_parse_get_trace(&power_trace, A_surfxml_cpu_availability_file); + + xbt_assert0((A_surfxml_cpu_state == A_surfxml_cpu_state_ON) || + (A_surfxml_cpu_state == A_surfxml_cpu_state_OFF), + "Invalid state"); + if (A_surfxml_cpu_state == A_surfxml_cpu_state_ON) + state_initial = SURF_CPU_ON; + if (A_surfxml_cpu_state == A_surfxml_cpu_state_OFF) + state_initial = SURF_CPU_OFF; + surf_parse_get_trace(&state_trace, A_surfxml_cpu_state_file); + + surf_parse_get_double(&interference_send, + A_surfxml_cpu_interference_send); + surf_parse_get_double(&interference_recv, + A_surfxml_cpu_interference_recv); + surf_parse_get_double(&interference_send_recv, + A_surfxml_cpu_interference_send_recv); + surf_parse_get_double(&max_outgoing_rate, + A_surfxml_cpu_max_outgoing_rate); + + cpu_new(A_surfxml_cpu_name, power_scale, power_initial, power_trace, + state_initial, state_trace, interference_send, interference_recv, + interference_send_recv, max_outgoing_rate); } -static void action_resume(surf_action_t action) +static void create_routing_table(void) { - if(action->resource_type==(surf_resource_t)surf_network_resource) - surf_network_resource->common_public->resume(action); - else if(action->resource_type==(surf_resource_t)surf_cpu_resource) - surf_cpu_resource->common_public->resume(action); - else DIE_IMPOSSIBLE; + routing_table = + xbt_new0(s_route_KCCFLN05_t, nb_workstation * nb_workstation); } -static int action_is_suspended(surf_action_t action) +static void network_link_free(void *nw_link) { - if(action->resource_type==(surf_resource_t)surf_network_resource) - return surf_network_resource->common_public->is_suspended(action); - if(action->resource_type==(surf_resource_t)surf_cpu_resource) - return surf_cpu_resource->common_public->is_suspended(action); - DIE_IMPOSSIBLE; + free(((network_link_KCCFLN05_t) nw_link)->name); + free(nw_link); } -static void action_set_max_duration(surf_action_t action, double duration) +static network_link_KCCFLN05_t network_link_new(char *name, + double bw_initial, + tmgr_trace_t bw_trace, + double lat_initial, + tmgr_trace_t lat_trace, + e_surf_network_link_state_t + state_initial, + tmgr_trace_t state_trace, + e_surf_network_link_sharing_policy_t policy) { - if(action->resource_type==(surf_resource_t)surf_network_resource) - surf_network_resource->common_public->set_max_duration(action,duration); - else if(action->resource_type==(surf_resource_t)surf_cpu_resource) - surf_cpu_resource->common_public->set_max_duration(action,duration); - else DIE_IMPOSSIBLE; -} + network_link_KCCFLN05_t nw_link = xbt_new0(s_network_link_KCCFLN05_t, 1); -/**************************************/ -/********* Module creation ***********/ -/**************************************/ -static void cpu_KCCFLN05_finalize(void) -{ - xbt_dict_free(&workstation_set); - xbt_swag_free(surf_cpu_resource->common_public->states.ready_action_set); - xbt_swag_free(surf_cpu_resource->common_public->states. - running_action_set); - xbt_swag_free(surf_cpu_resource->common_public->states. - failed_action_set); - xbt_swag_free(surf_cpu_resource->common_public->states.done_action_set); - free(surf_cpu_resource->common_public); - free(surf_cpu_resource->common_private); - free(surf_cpu_resource->extension_public); + nw_link->resource = (surf_resource_t) surf_workstation_resource; + nw_link->type = SURF_WORKSTATION_RESOURCE_LINK; + nw_link->name = name; + nw_link->bw_current = bw_initial; + if (bw_trace) + nw_link->bw_event = + tmgr_history_add_trace(history, bw_trace, 0.0, 0, nw_link); + nw_link->state_current = state_initial; + nw_link->lat_current = lat_initial; + if (lat_trace) + nw_link->lat_event = + tmgr_history_add_trace(history, lat_trace, 0.0, 0, nw_link); + if (state_trace) + nw_link->state_event = + tmgr_history_add_trace(history, state_trace, 0.0, 0, nw_link); + + nw_link->constraint = + lmm_constraint_new(maxmin_system, nw_link, nw_link->bw_current); - free(surf_cpu_resource); - surf_cpu_resource = NULL; + if(policy == SURF_NETWORK_LINK_FATPIPE) + lmm_constraint_shared(nw_link->constraint); - if (maxmin_system_cpu_KCCFLN05) { - lmm_system_free(maxmin_system_cpu_KCCFLN05); - maxmin_system_cpu_KCCFLN05 = NULL; - } + xbt_dict_set(network_link_set, name, nw_link, network_link_free); + + return nw_link; } -static void cpu_KCCFLN05_resource_init_internal(void) +static void parse_network_link(void) { - s_surf_action_t action; + char *name; + double bw_initial; + tmgr_trace_t bw_trace; + double lat_initial; + tmgr_trace_t lat_trace; + e_surf_network_link_state_t state_initial = SURF_NETWORK_LINK_ON; + e_surf_network_link_sharing_policy_t policy_initial = SURF_NETWORK_LINK_SHARED; + tmgr_trace_t state_trace; - surf_cpu_resource = xbt_new0(s_surf_cpu_resource_t, 1); + name = xbt_strdup(A_surfxml_network_link_name); + surf_parse_get_double(&bw_initial,A_surfxml_network_link_bandwidth); + surf_parse_get_trace(&bw_trace, A_surfxml_network_link_bandwidth_file); + surf_parse_get_double(&lat_initial,A_surfxml_network_link_latency); + surf_parse_get_trace(&lat_trace, A_surfxml_network_link_latency_file); - surf_cpu_resource->common_private = - xbt_new0(s_surf_resource_private_t, 1); - surf_cpu_resource->common_public = - xbt_new0(s_surf_resource_public_t, 1); + xbt_assert0((A_surfxml_network_link_state==A_surfxml_network_link_state_ON)|| + (A_surfxml_network_link_state==A_surfxml_network_link_state_OFF), + "Invalid state"); + if (A_surfxml_network_link_state==A_surfxml_network_link_state_ON) + state_initial = SURF_NETWORK_LINK_ON; + else if (A_surfxml_network_link_state==A_surfxml_network_link_state_OFF) + state_initial = SURF_NETWORK_LINK_OFF; - surf_cpu_resource->extension_public = - xbt_new0(s_surf_cpu_resource_extension_public_t, 1); + if (A_surfxml_network_link_sharing_policy==A_surfxml_network_link_sharing_policy_SHARED) + policy_initial = SURF_NETWORK_LINK_SHARED; + else if (A_surfxml_network_link_sharing_policy==A_surfxml_network_link_sharing_policy_FATPIPE) + policy_initial = SURF_NETWORK_LINK_FATPIPE; - surf_cpu_resource->common_public->states.ready_action_set = - xbt_swag_new(xbt_swag_offset(action, state_hookup)); - surf_cpu_resource->common_public->states.running_action_set = - xbt_swag_new(xbt_swag_offset(action, state_hookup)); - surf_cpu_resource->common_public->states.failed_action_set = - xbt_swag_new(xbt_swag_offset(action, state_hookup)); - surf_cpu_resource->common_public->states.done_action_set = - xbt_swag_new(xbt_swag_offset(action, state_hookup)); + surf_parse_get_trace(&state_trace,A_surfxml_network_link_state_file); - surf_cpu_resource->common_public->name_service = name_service; - surf_cpu_resource->common_public->get_resource_name = get_resource_name; - surf_cpu_resource->common_public->action_get_state = - surf_action_get_state; - surf_cpu_resource->common_public->action_free = action_cpu_KCCFLN05_free; - surf_cpu_resource->common_public->action_use = action_cpu_KCCFLN05_use; - surf_cpu_resource->common_public->action_cancel = NULL; - surf_cpu_resource->common_public->action_recycle = NULL; - surf_cpu_resource->common_public->action_change_state = action_cpu_KCCFLN05_change_state; - surf_cpu_resource->common_public->action_set_data = surf_action_set_data; - surf_cpu_resource->common_public->name = "CPU KCCFLN05"; - - surf_cpu_resource->common_private->resource_used = cpu_used; - surf_cpu_resource->common_private->share_resources = share_cpu_KCCFLN05_resources; - surf_cpu_resource->common_private->update_actions_state = - update_actions_cpu_KCCFLN05_state; - surf_cpu_resource->common_private->update_resource_state = - update_cpu_KCCFLN05_state; - surf_cpu_resource->common_private->finalize = cpu_KCCFLN05_finalize; - - surf_cpu_resource->extension_public->execute = execute_KCCFLN05; -/*FIXME*//* surf_cpu_resource->extension_public->sleep = action_sleep; */ - - surf_cpu_resource->common_public->suspend = cpu_KCCFLN05_action_suspend; - surf_cpu_resource->common_public->resume = cpu_KCCFLN05_action_resume; - surf_cpu_resource->common_public->is_suspended = cpu_KCCFLN05_action_is_suspended; - - surf_cpu_resource->extension_public->get_state = get_state; - - workstation_set = xbt_dict_new(); - - maxmin_system_cpu_KCCFLN05 = lmm_system_new(); + network_link_new(name, bw_initial, bw_trace, + lat_initial, lat_trace, state_initial, state_trace, + policy_initial); } -static void network_KCCFLN05_finalize(void) +static void route_new(int src_id, int dst_id, network_link_KCCFLN05_t *link_list, int nb_link, + double impact_on_src, double impact_on_dst, + double impact_on_src_with_other_recv, + double impact_on_dst_with_other_send) { - int i,j; + route_KCCFLN05_t route = &(ROUTE(src_id, dst_id)); + + route->size = nb_link; + route->links = link_list = xbt_realloc(link_list, sizeof(network_link_KCCFLN05_t) * nb_link); + route->impact_on_src = impact_on_src; + route->impact_on_dst = impact_on_src; + route->impact_on_src_with_other_recv = impact_on_src_with_other_recv; + route->impact_on_dst_with_other_send = impact_on_dst_with_other_send; +} - xbt_dict_free(&network_link_set); - xbt_swag_free(surf_network_resource->common_public->states. - ready_action_set); - xbt_swag_free(surf_network_resource->common_public->states. - running_action_set); - xbt_swag_free(surf_network_resource->common_public->states. - failed_action_set); - xbt_swag_free(surf_network_resource->common_public->states. - done_action_set); - free(surf_network_resource->common_public); - free(surf_network_resource->common_private); - free(surf_network_resource->extension_public); +static int nb_link; +static int link_list_capacity; +static network_link_KCCFLN05_t *link_list = NULL; +static int src_id = -1; +static int dst_id = -1; +static double impact_on_src; +static double impact_on_dst; +static double impact_on_src_with_other_recv; +static double impact_on_dst_with_other_send; - free(surf_network_resource); - surf_network_resource = NULL; +static void parse_route_set_endpoints(void) +{ + src_id = ((cpu_KCCFLN05_t) name_service(A_surfxml_route_src))->id; + dst_id = ((cpu_KCCFLN05_t) name_service(A_surfxml_route_dst))->id; + surf_parse_get_double(&impact_on_src, A_surfxml_route_impact_on_src); + surf_parse_get_double(&impact_on_dst, A_surfxml_route_impact_on_dst); + surf_parse_get_double(&impact_on_src_with_other_recv, + A_surfxml_route_impact_on_src_with_other_recv); + surf_parse_get_double(&impact_on_dst_with_other_send, + A_surfxml_route_impact_on_dst_with_other_send); - for (i = 0; i < nb_workstation; i++) - for (j = 0; j < nb_workstation; j++) - free(ROUTE(i,j).links); - free(routing_table); - routing_table = NULL; - nb_workstation = 0; + nb_link = 0; + link_list_capacity = 20; + link_list = xbt_new(network_link_KCCFLN05_t, link_list_capacity); +} - if (maxmin_system_network_KCCFLN05) { - lmm_system_free(maxmin_system_network_KCCFLN05); - maxmin_system_network_KCCFLN05 = NULL; +static void parse_route_elem(void) +{ + xbt_ex_t e; + if (nb_link == link_list_capacity) { + link_list_capacity *= 2; + link_list = xbt_realloc(link_list, (link_list_capacity) * sizeof(network_link_KCCFLN05_t)); + } + TRY { + link_list[nb_link++] = xbt_dict_get(network_link_set, A_surfxml_route_element_name); + } CATCH(e) { + RETHROW1("Link %s not found (dict raised this exception: %s)",A_surfxml_route_element_name); } } -static void network_KCCFLN05_resource_init_internal(void) +static void parse_route_set_route(void) { - s_surf_action_t action; - - surf_network_resource = xbt_new0(s_surf_network_resource_t, 1); + route_new(src_id, dst_id, link_list, nb_link, impact_on_src, + impact_on_dst, impact_on_src_with_other_recv, + impact_on_dst_with_other_send); +} - surf_network_resource->common_private = - xbt_new0(s_surf_resource_private_t, 1); - surf_network_resource->common_public = - xbt_new0(s_surf_resource_public_t, 1); - surf_network_resource->extension_public = - xbt_new0(s_surf_network_resource_extension_public_t, 1); +static void parse_file(const char *file) +{ + int i; - surf_network_resource->common_public->states.ready_action_set = - xbt_swag_new(xbt_swag_offset(action, state_hookup)); - surf_network_resource->common_public->states.running_action_set = - xbt_swag_new(xbt_swag_offset(action, state_hookup)); - surf_network_resource->common_public->states.failed_action_set = - xbt_swag_new(xbt_swag_offset(action, state_hookup)); - surf_network_resource->common_public->states.done_action_set = - xbt_swag_new(xbt_swag_offset(action, state_hookup)); + /* Figuring out the cpus */ + surf_parse_reset_parser(); + ETag_surfxml_cpu_fun = parse_cpu; + surf_parse_open(file); + xbt_assert1((!surf_parse()), "Parse error in %s", file); + surf_parse_close(); - surf_network_resource->common_public->name_service = name_service; - surf_network_resource->common_public->get_resource_name = get_resource_name; - surf_network_resource->common_public->action_get_state = - surf_action_get_state; - surf_network_resource->common_public->action_free = action_network_KCCFLN05_free; - surf_network_resource->common_public->action_use = action_network_KCCFLN05_use; - surf_network_resource->common_public->action_cancel = NULL; - surf_network_resource->common_public->action_recycle = NULL; - surf_network_resource->common_public->action_change_state = action_network_KCCFLN05_change_state; - surf_network_resource->common_public->action_set_data = surf_action_set_data; - surf_network_resource->common_public->name = "network KCCFLN05"; - - surf_network_resource->common_private->resource_used = link_used; - surf_network_resource->common_private->share_resources = share_network_KCCFLN05_resources; - surf_network_resource->common_private->update_actions_state = - update_actions_network_KCCFLN05_state; - surf_network_resource->common_private->update_resource_state = - update_network_KCCFLN05_state; - surf_network_resource->common_private->finalize = network_KCCFLN05_finalize; - - surf_network_resource->common_public->suspend = network_KCCFLN05_action_suspend; - surf_network_resource->common_public->resume = network_KCCFLN05_action_resume; - surf_network_resource->common_public->is_suspended = network_KCCFLN05_action_is_suspended; - - surf_network_resource->extension_public->communicate = communicate_KCCFLN05; + create_routing_table(); - network_link_set = xbt_dict_new(); + /* Figuring out the router (added after GTNETS) */ + surf_parse_reset_parser(); + STag_surfxml_router_fun=parse_route_set_routers; + surf_parse_open(file); + xbt_assert1((!surf_parse()),"Parse error in %s",file); + surf_parse_close(); - maxmin_system_network_KCCFLN05 = lmm_system_new(); -} + /* Figuring out the network links */ + surf_parse_reset_parser(); + ETag_surfxml_network_link_fun = parse_network_link; + surf_parse_open(file); + xbt_assert1((!surf_parse()), "Parse error in %s", file); + surf_parse_close(); -static void workstation_KCCFLN05_finalize(void) -{ - xbt_swag_free(surf_workstation_resource->common_public->states.ready_action_set); - xbt_swag_free(surf_workstation_resource->common_public->states.running_action_set); - xbt_swag_free(surf_workstation_resource->common_public->states.failed_action_set); - xbt_swag_free(surf_workstation_resource->common_public->states.done_action_set); + /* Building the routes */ + surf_parse_reset_parser(); + STag_surfxml_route_fun = parse_route_set_endpoints; + ETag_surfxml_route_element_fun = parse_route_elem; + ETag_surfxml_route_fun = parse_route_set_route; + surf_parse_open(file); + xbt_assert1((!surf_parse()), "Parse error in %s", file); + surf_parse_close(); - free(surf_workstation_resource->common_public); - free(surf_workstation_resource->common_private); - free(surf_workstation_resource->extension_public); + /* Adding loopback if needed */ + for (i = 0; i < nb_workstation; i++) + if(!ROUTE(i,i).size) { + if(!loopback) + loopback = network_link_new(xbt_strdup("__MSG_loopback__"), + 498000000, NULL, 0.000015, NULL, + SURF_NETWORK_LINK_ON, NULL, + SURF_NETWORK_LINK_FATPIPE); + ROUTE(i,i).size=1; + ROUTE(i,i).links = xbt_new0(network_link_KCCFLN05_t, 1); + ROUTE(i,i).links[0] = loopback; + } - free(surf_workstation_resource); - surf_workstation_resource = NULL; } -static void workstation_KCCFLN05_resource_init_internal(void) +/**************************************/ +/********* Module creation ***********/ +/**************************************/ + +static void resource_init_internal(void) { s_surf_action_t action; @@ -1045,58 +1077,103 @@ static void workstation_KCCFLN05_resource_init_internal(void) xbt_swag_new(xbt_swag_offset(action, state_hookup)); surf_workstation_resource->common_public->name_service = name_service; - surf_workstation_resource->common_public->get_resource_name = - get_resource_name; - surf_workstation_resource->common_public->action_get_state = - surf_action_get_state; - surf_workstation_resource->common_public->action_free = action_free; + surf_workstation_resource->common_public->get_resource_name = get_resource_name; + surf_workstation_resource->common_public->action_get_state = surf_action_get_state; + surf_workstation_resource->common_public->action_get_start_time = + surf_action_get_start_time; + surf_workstation_resource->common_public->action_get_finish_time = + surf_action_get_finish_time; surf_workstation_resource->common_public->action_use = action_use; - surf_workstation_resource->common_public->action_cancel = NULL; - surf_workstation_resource->common_public->action_recycle = NULL; - surf_workstation_resource->common_public->action_change_state = action_change_state; + surf_workstation_resource->common_public->action_free = action_free; + surf_workstation_resource->common_public->action_cancel = action_cancel; + surf_workstation_resource->common_public->action_recycle = action_recycle; + surf_workstation_resource->common_public->action_change_state = surf_action_change_state; surf_workstation_resource->common_public->action_set_data = surf_action_set_data; + surf_workstation_resource->common_public->suspend = action_suspend; + surf_workstation_resource->common_public->resume = action_resume; + surf_workstation_resource->common_public->is_suspended = action_is_suspended; + surf_workstation_resource->common_public->set_max_duration = action_set_max_duration; + surf_workstation_resource->common_public->set_priority = action_set_priority; surf_workstation_resource->common_public->name = "Workstation KCCFLN05"; surf_workstation_resource->common_private->resource_used = resource_used; surf_workstation_resource->common_private->share_resources = share_resources; surf_workstation_resource->common_private->update_actions_state = update_actions_state; surf_workstation_resource->common_private->update_resource_state = update_resource_state; - surf_workstation_resource->common_private->finalize = workstation_KCCFLN05_finalize; - - - surf_workstation_resource->common_public->suspend = action_suspend; - surf_workstation_resource->common_public->resume = action_resume; - surf_workstation_resource->common_public->is_suspended = action_is_suspended; - surf_workstation_resource->common_public->set_max_duration = action_set_max_duration; - - surf_workstation_resource->extension_public->execute = execute_KCCFLN05; -/*FIXME*//* surf_workstation_resource->extension_public->sleep = action_sleep; */ - surf_workstation_resource->extension_public->get_state = get_state; - surf_workstation_resource->extension_public->communicate = communicate_KCCFLN05; - surf_workstation_resource->extension_public->execute_parallel_task = - execute_parallel_task_KCCFLN05; + surf_workstation_resource->common_private->finalize = finalize; + + surf_workstation_resource->extension_public->execute = execute; + surf_workstation_resource->extension_public->sleep = action_sleep; + surf_workstation_resource->extension_public->get_state = resource_get_state; + surf_workstation_resource->extension_public->get_speed = get_speed; + surf_workstation_resource->extension_public->get_available_speed = get_available_speed; + surf_workstation_resource->extension_public->communicate = communicate; + surf_workstation_resource->extension_public->execute_parallel_task = execute_parallel_task; + surf_workstation_resource->extension_public->get_route = get_route; + surf_workstation_resource->extension_public->get_route_size = get_route_size; + surf_workstation_resource->extension_public->get_link_name = get_link_name; + surf_workstation_resource->extension_public->get_link_bandwidth = get_link_bandwidth; + surf_workstation_resource->extension_public->get_link_latency = get_link_latency; + + workstation_set = xbt_dict_new(); + router_set = xbt_dict_new(); + network_link_set = xbt_dict_new(); + xbt_assert0(maxmin_system, "surf_init has to be called first!"); } /**************************************/ /*************** Generic **************/ /**************************************/ - void surf_workstation_resource_init_KCCFLN05(const char *filename) { - xbt_assert0(!surf_cpu_resource,"CPU resource type already defined"); - cpu_KCCFLN05_resource_init_internal(); - xbt_assert0(!surf_network_resource,"network resource type already defined"); - network_KCCFLN05_resource_init_internal(); - workstation_KCCFLN05_resource_init_internal(); + xbt_assert0(!surf_cpu_resource, "CPU resource type already defined"); + xbt_assert0(!surf_network_resource, "network resource type already defined"); + resource_init_internal(); parse_file(filename); - xbt_dynar_push(resource_list, &surf_network_resource); - xbt_dynar_push(resource_list, &surf_cpu_resource); xbt_dynar_push(resource_list, &surf_workstation_resource); +} - if (maxmin_system) { /* To avoid using this useless system */ - lmm_system_free(maxmin_system); - maxmin_system = NULL; - } +void surf_workstation_resource_init_KCCFLN05_proportional(const char *filename) +{ + xbt_assert0(!surf_cpu_resource, "CPU resource type already defined"); + xbt_assert0(!surf_network_resource, "network resource type already defined"); + resource_init_internal(); + parse_file(filename); + + surf_workstation_resource->common_public->name = "Workstation KCCFLN05 (proportional)"; + use_sdp_solver=1; + xbt_dynar_push(resource_list, &surf_workstation_resource); +} + +void surf_workstation_resource_init_KCCFLN05_Vegas(const char *filename) +{ + xbt_assert0(!surf_cpu_resource, "CPU resource type already defined"); + xbt_assert0(!surf_network_resource, "network resource type already defined"); + resource_init_internal(); + parse_file(filename); + + lmm_set_default_protocol_function(func_vegas_f, func_vegas_fp, func_vegas_fpi); + + surf_workstation_resource->common_public->name = "Workstation KCCFLN05 (Vegas)"; + use_lagrange_solver=1; + xbt_dynar_push(resource_list, &surf_workstation_resource); +} + +void surf_workstation_resource_init_KCCFLN05_Reno(const char *filename) +{ + xbt_assert0(!surf_cpu_resource, "CPU resource type already defined"); + xbt_assert0(!surf_network_resource, "network resource type already defined"); + resource_init_internal(); + parse_file(filename); + + lmm_set_default_protocol_function(func_reno_f, func_reno_fp, func_reno_fpi); + + surf_workstation_resource->common_public->name = "Workstation KCCFLN05 (Reno)"; + use_lagrange_solver=1; + xbt_dynar_push(resource_list, &surf_workstation_resource); } + + +