X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/841d5e83050a1c7a247ab9edfc5e3185663d996d..294430954d6bdfd2bdf43fcc49fde087be1474c6:/src/surf/workstation_KCCFLN05.c diff --git a/src/surf/workstation_KCCFLN05.c b/src/surf/workstation_KCCFLN05.c index f3c9115c39..5695942d6a 100644 --- a/src/surf/workstation_KCCFLN05.c +++ b/src/surf/workstation_KCCFLN05.c @@ -5,958 +5,1331 @@ /* 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" +#include "surf_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)"); +typedef enum { + SURF_WORKSTATION_RESOURCE_CPU, + SURF_WORKSTATION_RESOURCE_LINK, +} e_surf_workstation_model_type_t; -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; -s_route_KCCFLN05_t *routing_table = NULL; -#define ROUTE(i,j) routing_table[(i)+(j)*nb_workstation] /**************************************/ -/************* CPU object *************/ +/********* router object **************/ /**************************************/ +typedef struct router_KCCFLN05 { + char *name; + unsigned int id; +} s_router_KCCFLN05_t, *router_KCCFLN05_t; -/************ workstation creation *********/ -static void workstation_free(void *workstation) -{ - xbt_free(((workstation_KCCFLN05_t)workstation)->name); - xbt_dynar_free(&(((workstation_KCCFLN05_t)workstation)->incomming_communications)); - xbt_dynar_free(&(((workstation_KCCFLN05_t)workstation)->outgoing_communications)); - xbt_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) -{ - 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++; +/**************************************/ +/********* cpu object *****************/ +/**************************************/ +typedef struct cpu_KCCFLN05 { + surf_model_t model; + xbt_dict_t properties; /* Do not move this field */ + e_surf_workstation_model_type_t type; /* Do not move this field */ + char *name; /* Do not move this field */ + lmm_constraint_t constraint; + lmm_constraint_t bus; + double power_scale; + double power_current; + double interference_send; + double interference_recv; + double interference_send_recv; + tmgr_trace_event_t power_event; + e_surf_cpu_state_t state_current; + tmgr_trace_event_t state_event; + int id; /* cpu and network card are a single object... */ + xbt_dynar_t incomming_communications; + xbt_dynar_t outgoing_communications; +} s_cpu_KCCFLN05_t, *cpu_KCCFLN05_t; - workstation->power_scale = power_scale; - workstation->power_current = power_initial; - if (power_trace) - workstation->power_event = - tmgr_history_add_trace(history, power_trace, 0.0, 0, workstation); +/**************************************/ +/*********** network object ***********/ +/**************************************/ - workstation->state_current = state_initial; - if (state_trace) - workstation->state_event = - tmgr_history_add_trace(history, state_trace, 0.0, 0, workstation); +typedef struct link_KCCFLN05 { + surf_model_t model; + xbt_dict_t properties; /* Do not move this field */ + e_surf_workstation_model_type_t type; /* Do not move this field */ + char *name; /* Do not move this field */ + lmm_constraint_t constraint; + double lat_current; + tmgr_trace_event_t lat_event; + double bw_current; + tmgr_trace_event_t bw_event; + e_surf_link_state_t state_current; + tmgr_trace_event_t state_event; +} s_link_KCCFLN05_t, *link_KCCFLN05_t; + + +typedef struct s_route_KCCFLN05 { + double impact_on_src; + double impact_on_dst; + double impact_on_src_with_other_recv; + double impact_on_dst_with_other_send; + link_KCCFLN05_t *links; + int size; +} s_route_KCCFLN05_t, *route_KCCFLN05_t; - workstation->interference_send=interference_send; - workstation->interference_recv=interference_recv; - workstation->interference_send_recv=interference_send_recv; +/**************************************/ +/*************** actions **************/ +/**************************************/ +typedef struct surf_action_workstation_KCCFLN05 { + s_surf_action_t generic_action; + double latency; + double lat_current; + lmm_variable_t variable; + double rate; + int suspended; + cpu_KCCFLN05_t src; /* could be avoided */ + cpu_KCCFLN05_t dst; /* could be avoided */ +} s_surf_action_workstation_KCCFLN05_t, + *surf_action_workstation_KCCFLN05_t; - workstation->constraint = - lmm_constraint_new(maxmin_system_cpu_KCCFLN05, workstation, - workstation->power_current * workstation->power_scale); - 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); +static int nb_workstation = 0; +static s_route_KCCFLN05_t *routing_table = NULL; +#define ROUTE(i,j) routing_table[(i)+(j)*nb_workstation] +static link_KCCFLN05_t loopback = NULL; +static xbt_dict_t parallel_task_link_set = NULL; +//added to work with GTNETS +static xbt_dict_t router_set = NULL; +static lmm_system_t maxmin_system = NULL; +/*xbt_dict_t link_set = NULL;*/ - 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; - - 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); - - workstation_new(A_cpu_name, power_scale, power_initial, power_trace, state_initial, - state_trace, interference_send, interference_recv, - interference_send_recv); + 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); + xbt_ex_t e; + void *res = NULL; + + TRY { + res = xbt_dict_get(workstation_set, name); + } CATCH(e) { + if (e.category != not_found_error) + RETHROW; + WARN1("Host '%s' not found, verifing if it is a router", name); + res = NULL; + xbt_ex_free(e); + } - return workstation; + return res; } static const char *get_resource_name(void *resource_id) { - return ((workstation_KCCFLN05_t) resource_id)->name; + /* We can freely cast as a cpu_KCCFLN05_t because it has the same + prefix as link_KCCFLN05_t. However, only cpu_KCCFLN05_t + will theoretically be given as an argument here. */ + return ((cpu_KCCFLN05_t) resource_id)->name; } -static int cpu_used(void *resource_id) +/* action_get_state is inherited from the surf module */ + +static void action_use(surf_action_t action) { - return lmm_constraint_used(maxmin_system_cpu_KCCFLN05, - ((workstation_KCCFLN05_t) resource_id)->constraint); + action->using++; + return; } -static int link_used(void *resource_id) +static int action_free(surf_action_t action) { - return lmm_constraint_used(maxmin_system_network_KCCFLN05, - ((network_link_KCCFLN05_t) resource_id)->constraint); + 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; + + 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; + } + + if (dst) + xbt_dynar_foreach(dst->incomming_communications, cpt, act) + if (act == action) { + xbt_dynar_remove_at(dst->incomming_communications, cpt, &act); + break; + } + + if (src && (!xbt_dynar_length(src->outgoing_communications))) + __update_cpu_usage(src); + if (dst && (!xbt_dynar_length(dst->incomming_communications))) + __update_cpu_usage(dst); + + free(action); + return 1; + } + return 0; } -static e_surf_cpu_state_t get_state(void *cpu) +static void action_cancel(surf_action_t action) { - return ((workstation_KCCFLN05_t) cpu)->state_current; + surf_action_change_state(action, SURF_ACTION_FAILED); + return; } -static void update_cpu_KCCFLN05_state(void *id, - tmgr_trace_event_t event_type, - double value) +static void action_recycle(surf_action_t action) { - 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(); - } - + DIE_IMPOSSIBLE; return; } -/**************************************/ -/*********** network object ***********/ -/**************************************/ +/* action_change_state is inherited from the surf module */ +/* action_set_data is inherited from the surf module */ -static void create_routing_table(void) +static void action_suspend(surf_action_t action) { - routing_table = xbt_new0(s_route_KCCFLN05_t, nb_workstation * nb_workstation); + 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 network_link_free(void *nw_link) +static void action_resume(surf_action_t action) { - xbt_free(((network_link_KCCFLN05_t)nw_link)->name); - xbt_free(nw_link); + 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, action->priority); + 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 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_is_suspended(surf_action_t action) { - network_link_KCCFLN05_t nw_link = xbt_new0(s_network_link_KCCFLN05_t, 1); + return (((surf_action_workstation_KCCFLN05_t) action)->suspended == 1); +} +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; +} - 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); - nw_link->constraint = - lmm_constraint_new(maxmin_system_network_KCCFLN05, nw_link, nw_link->bw_current); +static void action_set_priority(surf_action_t action, double priority) +{ + XBT_IN2("(%p,%g)", action, priority); + action->priority = priority; + lmm_update_variable_weight(maxmin_system, ((surf_action_workstation_KCCFLN05_t) action)->variable, priority); - xbt_dict_set(network_link_set, name, nw_link, network_link_free); + XBT_OUT; +} + +/**************************************/ +/******* Resource Private **********/ +/**************************************/ + +static int resource_used(void *resource_id) +{ + /* We can freely cast as a 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, + ((link_KCCFLN05_t) resource_id)-> + constraint); - return nw_link; } -static void parse_network_link(void) +static double share_resources(double now) { - 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; + s_surf_action_workstation_KCCFLN05_t s_action; + surf_action_workstation_KCCFLN05_t action = NULL; - 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_swag_t running_actions = + surf_workstation_model->common_public->states.running_action_set; + double min = generic_maxmin_share_resources(running_actions, + xbt_swag_offset(s_action, + variable), + maxmin_system, + lmm_solve); + + 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->latency < min) { + min = action->latency; + DEBUG3("Updating min (latency) with %p (start %f): %f", action, + action->generic_action.start, min); + } + } + } - 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); + DEBUG1("min value : %f", min); - network_link_new(name, bw_initial, bw_trace, state_initial, state_trace); + return min; } -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 update_actions_state(double now, double delta) { - network_link_KCCFLN05_t *link_list = NULL; - int i; - route_KCCFLN05_t route = &(ROUTE(src_id,dst_id)); + 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_workstation_model->common_public->states.running_action_set; - 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])); - xbt_free(links[i]); - } - xbt_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; -} + xbt_swag_foreach_safe(action, next_action, running_actions) { + 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); -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; + if (action->generic_action.max_duration != NO_MAX_DURATION) + double_update(&(action->generic_action.max_duration), delta); -static void parse_route_set_endpoints(void) -{ - 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); + if ((action->generic_action.remains <= 0) && + (lmm_get_variable_weight(action->variable) > 0)) { + action->generic_action.finish = surf_get_clock(); + 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)) { + action->generic_action.finish = surf_get_clock(); + surf_action_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; + void *constraint_id = NULL; - nb_link = 0; - link_name = NULL; + while ((cnst = + lmm_get_cnst_from_var(maxmin_system, action->variable, + i++))) { + constraint_id = lmm_constraint_id(cnst); + +/* if(((link_KCCFLN05_t)constraint_id)->type== */ +/* SURF_WORKSTATION_RESOURCE_LINK) { */ +/* DEBUG2("Checking for link %s (%p)", */ +/* ((link_KCCFLN05_t)constraint_id)->name, */ +/* ((link_KCCFLN05_t)constraint_id)); */ +/* } */ +/* if(((cpu_KCCFLN05_t)constraint_id)->type== */ +/* SURF_WORKSTATION_RESOURCE_CPU) { */ +/* DEBUG3("Checking for cpu %s (%p) : %s", */ +/* ((cpu_KCCFLN05_t)constraint_id)->name, */ +/* ((cpu_KCCFLN05_t)constraint_id), */ +/* ((cpu_KCCFLN05_t)constraint_id)->state_current==SURF_CPU_OFF?"Off":"On"); */ +/* } */ + + if (((((link_KCCFLN05_t) constraint_id)->type == + SURF_WORKSTATION_RESOURCE_LINK) && + (((link_KCCFLN05_t) constraint_id)->state_current == + SURF_LINK_OFF)) || + ((((cpu_KCCFLN05_t) constraint_id)->type == + SURF_WORKSTATION_RESOURCE_CPU) && + (((cpu_KCCFLN05_t) constraint_id)->state_current == + SURF_CPU_OFF))) { + DEBUG1("Action (%p) Failed!!", action); + action->generic_action.finish = surf_get_clock(); + surf_action_change_state((surf_action_t) action, + SURF_ACTION_FAILED); + break; + } + } + } + } + return; } -static void parse_route_elem(void) +static void update_resource_state(void *id, + tmgr_trace_event_t event_type, + double value) { - nb_link++; - link_name = xbt_realloc(link_name, (nb_link) * sizeof(char *)); - link_name[(nb_link) - 1] = xbt_strdup(A_route_element_name); -} + cpu_KCCFLN05_t cpu = id; + link_KCCFLN05_t nw_link = id; + + if (nw_link->type == SURF_WORKSTATION_RESOURCE_LINK) { + DEBUG2("Updating link %s (%p)", nw_link->name, nw_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); -static void parse_route_set_route(void) -{ - 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); + + } + } else if (event_type == nw_link->state_event) { + if (value > 0) + nw_link->state_current = SURF_LINK_ON; + else + nw_link->state_current = SURF_LINK_OFF; + } else { + CRITICAL0("Unknown event ! \n"); + xbt_abort(); + } + return; + } else if (cpu->type == SURF_WORKSTATION_RESOURCE_CPU) { + DEBUG3("Updating cpu %s (%p) with value %g", cpu->name, cpu, value); + 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; } -static void parse_file(const char *file) +static void finalize(void) { - /* 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(); + int i, j; - create_routing_table(); + xbt_dict_free(&link_set); + xbt_dict_free(&workstation_set); + xbt_dict_free(&router_set); + if (parallel_task_link_set != NULL) { + xbt_dict_free(¶llel_task_link_set); + } + xbt_swag_free(surf_workstation_model->common_public->states. + ready_action_set); + xbt_swag_free(surf_workstation_model->common_public->states. + running_action_set); + xbt_swag_free(surf_workstation_model->common_public->states. + failed_action_set); + xbt_swag_free(surf_workstation_model->common_public->states. + done_action_set); - /* 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(); + free(surf_workstation_model->common_public); + free(surf_workstation_model->common_private); + free(surf_workstation_model->extension_public); - /* 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(); -} + free(surf_workstation_model); + surf_workstation_model = NULL; -static void update_network_KCCFLN05_state(void *id, - tmgr_trace_event_t event_type, - double value) -{ - network_link_KCCFLN05_t nw_link = id; + 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; - 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(); + if (maxmin_system) { + lmm_system_free(maxmin_system); + maxmin_system = NULL; } - - return; } /**************************************/ -/*************** actions **************/ +/******* Resource Private **********/ /**************************************/ -/*************** network **************/ -static void action_network_KCCFLN05_free(surf_action_t action) + +static surf_action_t execute(void *cpu, double size) { - 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; + surf_action_workstation_KCCFLN05_t action = NULL; + cpu_KCCFLN05_t CPU = cpu; - xbt_swag_remove(action, action->state_set); - lmm_variable_free(maxmin_system_network_KCCFLN05, - ((surf_action_network_KCCFLN05_t) action)->variable); + XBT_IN2("(%s,%g)", CPU->name, size); + action = xbt_new0(s_surf_action_workstation_KCCFLN05_t, 1); - xbt_dynar_foreach (src->outgoing_communications,cpt,act) { - if(act==action) { - xbt_dynar_remove_at(src->outgoing_communications, cpt, &act); - break; - } - } + 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.model_type = + (surf_model_t) surf_workstation_model; + action->suspended = 0; - xbt_dynar_foreach (dst->incomming_communications,cpt,act) { - if(act==action) { - xbt_dynar_remove_at(dst->incomming_communications, cpt, &act); - break; - } - } + if (CPU->state_current == SURF_CPU_ON) + action->generic_action.state_set = + surf_workstation_model->common_public->states. + running_action_set; + else + action->generic_action.state_set = + surf_workstation_model->common_public->states.failed_action_set; + xbt_swag_insert(action, action->generic_action.state_set); - xbt_free(action); + 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_network_KCCFLN05_resources(double now) +static surf_action_t action_sleep(void *cpu, double duration) { - 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); + surf_action_workstation_KCCFLN05_t action = NULL; + + XBT_IN2("(%s,%g)", ((cpu_KCCFLN05_t) cpu)->name, duration); + + 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); + + XBT_OUT; + return (surf_action_t) action; } -static void action_network_KCCFLN05_change_state(surf_action_t action, - e_surf_action_state_t state) +static e_surf_cpu_state_t resource_get_state(void *cpu) { - surf_action_change_state(action, state); - return; + return ((cpu_KCCFLN05_t) cpu)->state_current; } -static void update_actions_network_KCCFLN05_state(double now, double delta) +static double get_speed(void *cpu, double load) { - surf_action_network_KCCFLN05_t action = NULL; - surf_action_network_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; - - xbt_swag_foreach_safe(action, next_action, running_actions) { - 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_network_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_network_KCCFLN05_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 */ - } - } + return load * (((cpu_KCCFLN05_t) cpu)->power_scale); +} - xbt_swag_foreach_safe(action, next_action, failed_actions) { - lmm_variable_disable(maxmin_system_network_KCCFLN05, action->variable); - } +static double get_available_speed(void *cpu) +{ + return ((cpu_KCCFLN05_t) cpu)->power_current; +} - return; +static xbt_dict_t get_cpu_properties(void *cpu) +{ + return ((cpu_KCCFLN05_t) cpu)->properties; } -static surf_action_t communicate_KCCFLN05(void *src, void *dst, double size) +static surf_action_t communicate(void *src, void *dst, double size, + double rate) { - 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); + 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; - action = xbt_new0(s_surf_action_network_KCCFLN05_t, 1); + 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_workstation_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.start = surf_get_clock(); action->generic_action.finish = -1.0; - action->generic_action.resource_type = - (surf_resource_t) surf_network_resource; - + action->src = src; + action->dst = dst; + action->generic_action.model_type = + (surf_model_t) surf_workstation_model; + action->suspended = 0; /* Should be useless because of the + calloc but it seems to help valgrind... */ action->generic_action.state_set = - surf_network_resource->common_public->states.running_action_set; + surf_workstation_model->common_public->states.running_action_set; + + xbt_dynar_push(card_src->outgoing_communications, &action); + xbt_dynar_push(card_dst->incomming_communications, &action); 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); + + 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); + } - action->variable = lmm_variable_new(maxmin_system_network_KCCFLN05, action, 1.0, -1.0, - route->size); + lmm_update_variable_latency(maxmin_system, action->variable, + action->latency); /* Should be useless */ - for (i = 0; i < route->size; i++) - lmm_expand(maxmin_system_network_KCCFLN05, route->links[i]->constraint, + for (i = 0; i < route_size; i++) + lmm_expand(maxmin_system, route->links[i]->constraint, action->variable, 1.0); - - action->src=src; - action->dst=dst; - - xbt_dynar_push(card_src->outgoing_communications,&action); - xbt_dynar_push(card_dst->incomming_communications,&action); - + 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; } -/***************** CPU ****************/ -static void action_cpu_KCCFLN05_free(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) { - xbt_swag_remove(action, action->state_set); - lmm_variable_free(maxmin_system_cpu_KCCFLN05, ((surf_action_cpu_KCCFLN05_t)action)->variable); - xbt_free(action); -} - -/* #define WARNING(format, ...) (fprintf(stderr, "[%s , %s : %d] ", __FILE__, __FUNCTION__, __LINE__),\ */ -/* fprintf(stderr, format, ## __VA_ARGS__), \ */ -/* fprintf(stderr, "\n")) */ -/* #define VOIRP(expr) WARNING(" {" #expr " = %p }", expr) */ -/* #define VOIRD(expr) WARNING(" {" #expr " = %d }", expr) */ -/* #define VOIRG(expr) WARNING(" {" #expr " = %lg }", expr) */ + surf_action_workstation_KCCFLN05_t action = NULL; + int i, j, k; + int nb_link = 0; + int nb_host = 0; + + if (parallel_task_link_set == NULL) { + parallel_task_link_set = + xbt_dict_new_ext(workstation_nb * workstation_nb * 10); + } -static double share_cpu_KCCFLN05_resources(double now) -{ - 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; - - 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); - } - 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); - } - 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); + /* 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; + 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_link_set, route[k]->name, + route[k], NULL); } - xbt_assert0(scale>0.0,"Negative interference !"); - } - lmm_update_constraint_bound(maxmin_system_cpu_KCCFLN05,workstation->constraint, - W*scale); } + } + nb_link = xbt_dict_length(parallel_task_link_set); + xbt_dict_reset(parallel_task_link_set); - 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); -} -static void update_actions_cpu_KCCFLN05_state(double now, double delta) -{ - 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; + for (i = 0; i < workstation_nb; i++) + if (computation_amount[i] > 0) + nb_host++; - xbt_swag_foreach_safe(action, next_action, running_actions) { - 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(); - 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)) { - action->generic_action.finish = surf_get_clock(); - surf_action_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; + 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 = surf_get_clock(); + action->generic_action.finish = -1.0; + action->generic_action.model_type = + (surf_model_t) surf_workstation_model; + action->suspended = 0; /* Should be useless because of the + calloc but it seems to help valgrind... */ + action->generic_action.state_set = + surf_workstation_model->common_public->states.running_action_set; - 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(); - surf_action_change_state((surf_action_t) action, SURF_ACTION_FAILED); - break; + 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; i < workstation_nb; i++) + if (computation_amount[i] > 0) + lmm_expand(maxmin_system, + ((cpu_KCCFLN05_t) workstation_list[i])->constraint, + action->variable, computation_amount[i]); + + 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; + 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]); } } } } - xbt_swag_foreach_safe(action, next_action, failed_actions) { - lmm_variable_disable(maxmin_system_cpu_KCCFLN05, action->variable); + if (nb_link + nb_host == 0) { + action->generic_action.cost = 1.0; + action->generic_action.remains = 0.0; } - return; + return (surf_action_t) action; } -static surf_action_t execute_KCCFLN05(void *cpu, double size) +/* returns an array of link_KCCFLN05_t */ +static const void **get_route(void *src, void *dst) { - surf_action_cpu_KCCFLN05_t action = NULL; - workstation_KCCFLN05_t CPU = cpu; - - action = xbt_new0(s_surf_action_cpu_KCCFLN05_t, 1); - - action->generic_action.cost = size; - action->generic_action.remains = size; - 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_cpu_resource; + cpu_KCCFLN05_t card_src = src; + cpu_KCCFLN05_t card_dst = dst; + route_KCCFLN05_t route = &(ROUTE(card_src->id, card_dst->id)); - 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->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); - - return (surf_action_t) action; + return (const void **) route->links; } -static void cpu_KCCFLN05_action_suspend(surf_action_t action) +static int get_route_size(void *src, void *dst) { - if(action->resource_type==(surf_resource_t)surf_network_resource) - lmm_update_variable_weight(maxmin_system_network_KCCFLN05, - ((surf_action_network_KCCFLN05_t) action)->variable, 0.0); - else if(action->resource_type==(surf_resource_t)surf_cpu_resource) - lmm_update_variable_weight(maxmin_system_cpu_KCCFLN05, - ((surf_action_cpu_KCCFLN05_t) action)->variable, 0.0); - else DIE_IMPOSSIBLE; + 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_resume(surf_action_t action) +static const char *get_link_name(const void *link) { - if(action->resource_type==(surf_resource_t)surf_network_resource) - lmm_update_variable_weight(maxmin_system_network_KCCFLN05, - ((surf_action_network_KCCFLN05_t) action)->variable, 1.0); - else if(action->resource_type==(surf_resource_t)surf_cpu_resource) - lmm_update_variable_weight(maxmin_system_cpu_KCCFLN05, - ((surf_action_cpu_KCCFLN05_t) action)->variable, 1.0); - else DIE_IMPOSSIBLE; + return ((link_KCCFLN05_t) link)->name; } -static int cpu_KCCFLN05_action_is_suspended(surf_action_t action) +static double get_link_bandwidth(const void *link) { - if(action->resource_type==(surf_resource_t)surf_network_resource) - return (lmm_get_variable_weight(((surf_action_cpu_KCCFLN05_t) action)->variable) == 0.0); - if(action->resource_type==(surf_resource_t)surf_cpu_resource) - return (lmm_get_variable_weight(((surf_action_network_KCCFLN05_t) action)->variable) == 0.0); - DIE_IMPOSSIBLE; + return ((link_KCCFLN05_t) link)->bw_current; } -/************* workstation ************/ -static void action_change_state(surf_action_t action, - e_surf_action_state_t state) +static double get_link_latency(const void *link) { - xbt_assert0(0, "Workstation is a virtual resource. I should not be there!"); - surf_action_change_state(action, state); - return; + return ((link_KCCFLN05_t) link)->lat_current; } -static void action_free(surf_action_t action) +static xbt_dict_t get_link_properties(void *link) { - xbt_assert0(0, "Workstation is a virtual resource. I should not be there!"); - return; + return ((link_KCCFLN05_t) link)->properties; } -static int resource_used(void *resource_id) + +/**************************************/ +/*** Resource Creation & Destruction **/ +/**************************************/ + + +static void router_free(void *router) { - xbt_assert0(0, "Workstation is a virtual resource. I should not be there!"); - return 0; + free(((router_KCCFLN05_t) router)->name); } -static double share_resources(double now) +static void router_new(const char *name) { - return -1.0; + static unsigned int nb_routers = 0; + router_KCCFLN05_t router; + + INFO1("Creating a router %s", name); + + router = xbt_new0(s_router_KCCFLN05_t, 1); + + router->name = xbt_strdup(name); + router->id = nb_routers++; + xbt_dict_set(router_set, name, router, router_free); } -static void update_actions_state(double now, double delta) +static void parse_routers(void) { - return; + //add a dumb router just to be GTNETS compatible + router_new(A_surfxml_router_id); } -static void update_resource_state(void *id, - tmgr_trace_event_t event_type, - double value) +static void cpu_free(void *cpu) { - xbt_assert0(0, "Workstation is a virtual resource. I should not be there!"); - 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 action_suspend(surf_action_t action) +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_dict_t cpu_properties_k) { - xbt_assert0(action->resource_type == - ((surf_resource_t) surf_cpu_resource), - "Resource type mismatch"); - surf_cpu_resource->extension_public->suspend(action); + cpu_KCCFLN05_t cpu = xbt_new0(s_cpu_KCCFLN05_t, 1); + + cpu->model = (surf_model_t) surf_workstation_model; + 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); + + /*add the property set*/ + cpu->properties = current_property_set; + + xbt_dict_set(workstation_set, name, cpu, cpu_free); + + return cpu; } -static void action_resume(surf_action_t action) +static void create_routing_table(void) { - xbt_assert0(action->resource_type == - ((surf_resource_t) surf_cpu_resource), - "Resource type mismatch"); - surf_cpu_resource->extension_public->resume(action); + routing_table = xbt_new0(s_route_KCCFLN05_t, nb_workstation * nb_workstation); } -static int action_is_suspended(surf_action_t action) +static void parse_cpu_init(void) { - if(action->resource_type==(surf_resource_t)surf_network_resource) - return 0; - if(action->resource_type==(surf_resource_t)surf_cpu_resource) - return surf_cpu_resource->extension_public->is_suspended(action); - 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_host_power); + surf_parse_get_double(&power_initial, A_surfxml_host_availability); + surf_parse_get_trace(&power_trace, A_surfxml_host_availability_file); + + xbt_assert0((A_surfxml_host_state == A_surfxml_host_state_ON) || + (A_surfxml_host_state == A_surfxml_host_state_OFF), + "Invalid state"); + if (A_surfxml_host_state == A_surfxml_host_state_ON) + state_initial = SURF_CPU_ON; + if (A_surfxml_host_state == A_surfxml_host_state_OFF) + state_initial = SURF_CPU_OFF; + surf_parse_get_trace(&state_trace, A_surfxml_host_state_file); + + surf_parse_get_double(&interference_send, + A_surfxml_host_interference_send); + surf_parse_get_double(&interference_recv, + A_surfxml_host_interference_recv); + surf_parse_get_double(&interference_send_recv, + A_surfxml_host_interference_send_recv); + surf_parse_get_double(&max_outgoing_rate, + A_surfxml_host_max_outgoing_rate); + current_property_set = xbt_dict_new(); + cpu_new(A_surfxml_host_id, power_scale, power_initial, power_trace, + state_initial, state_trace, interference_send, interference_recv, + interference_send_recv, max_outgoing_rate,/*add the properties*/current_property_set); } - -/**************************************/ -/********* Module creation ***********/ -/**************************************/ -static void cpu_KCCFLN05_finalize(void) +static void link_free(void *nw_link) { - 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); - xbt_free(surf_cpu_resource->common_public); - xbt_free(surf_cpu_resource->common_private); - xbt_free(surf_cpu_resource->extension_public); - - xbt_free(surf_cpu_resource); - surf_cpu_resource = NULL; - - if (maxmin_system_cpu_KCCFLN05) { - lmm_system_free(maxmin_system_cpu_KCCFLN05); - maxmin_system_cpu_KCCFLN05 = NULL; - } + free(((link_KCCFLN05_t) nw_link)->name); + free(nw_link); } -static void cpu_KCCFLN05_resource_init_internal(void) +static link_KCCFLN05_t link_new(char *name, + double bw_initial, + tmgr_trace_t bw_trace, + double lat_initial, + tmgr_trace_t lat_trace, + e_surf_link_state_t + state_initial, + tmgr_trace_t state_trace, + e_surf_link_sharing_policy_t + policy, xbt_dict_t properties_args) { - s_surf_action_t action; + link_KCCFLN05_t nw_link = xbt_new0(s_link_KCCFLN05_t, 1); - surf_cpu_resource = xbt_new0(s_surf_cpu_resource_t, 1); - 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); + nw_link->model = (surf_model_t) surf_workstation_model; + 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); - surf_cpu_resource->extension_public = - xbt_new0(s_surf_cpu_resource_extension_public_t, 1); + nw_link->constraint = + lmm_constraint_new(maxmin_system, nw_link, nw_link->bw_current); - 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)); + if (policy == SURF_LINK_FATPIPE) + lmm_constraint_shared(nw_link->constraint); - 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_cancel = NULL; - surf_cpu_resource->common_public->action_recycle = NULL; - surf_cpu_resource->common_public->action_change_state = surf_action_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->extension_public->suspend = cpu_KCCFLN05_action_suspend; - surf_cpu_resource->extension_public->resume = cpu_KCCFLN05_action_resume; - surf_cpu_resource->extension_public->is_suspended = cpu_KCCFLN05_action_is_suspended; - - surf_cpu_resource->extension_public->get_state = get_state; + /*add the property set*/ + nw_link->properties = properties_args; - workstation_set = xbt_dict_new(); + xbt_dict_set(link_set, name, nw_link, link_free); - maxmin_system_cpu_KCCFLN05 = lmm_system_new(); + return nw_link; } -static void network_KCCFLN05_finalize(void) +static void parse_link_init(void) { - int i,j; + char *name_link; + double bw_initial; + tmgr_trace_t bw_trace; + double lat_initial; + tmgr_trace_t lat_trace; + e_surf_link_state_t state_initial_link = SURF_LINK_ON; + e_surf_link_sharing_policy_t policy_initial_link = SURF_LINK_SHARED; + tmgr_trace_t state_trace; - 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); - xbt_free(surf_network_resource->common_public); - xbt_free(surf_network_resource->common_private); - xbt_free(surf_network_resource->extension_public); + name_link = xbt_strdup(A_surfxml_link_id); + surf_parse_get_double(&bw_initial, A_surfxml_link_bandwidth); + surf_parse_get_trace(&bw_trace, A_surfxml_link_bandwidth_file); + surf_parse_get_double(&lat_initial, A_surfxml_link_latency); + surf_parse_get_trace(&lat_trace, A_surfxml_link_latency_file); + + xbt_assert0((A_surfxml_link_state == + A_surfxml_link_state_ON) + || (A_surfxml_link_state == + A_surfxml_link_state_OFF), "Invalid state"); + if (A_surfxml_link_state == A_surfxml_link_state_ON) + state_initial_link = SURF_LINK_ON; + else if (A_surfxml_link_state == + A_surfxml_link_state_OFF) + state_initial_link = SURF_LINK_OFF; + + if (A_surfxml_link_sharing_policy == + A_surfxml_link_sharing_policy_SHARED) + policy_initial_link = SURF_LINK_SHARED; + else if (A_surfxml_link_sharing_policy == + A_surfxml_link_sharing_policy_FATPIPE) + policy_initial_link = SURF_LINK_FATPIPE; + + surf_parse_get_trace(&state_trace, A_surfxml_link_state_file); + + current_property_set = xbt_dict_new(); + link_new(name_link, bw_initial, bw_trace, + lat_initial, lat_trace, state_initial_link, state_trace, + policy_initial_link,/*add properties*/current_property_set); +} - xbt_free(surf_network_resource); - surf_network_resource = NULL; +static void route_new(int src_id, int dst_id, + 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) +{ + route_KCCFLN05_t route = &(ROUTE(src_id, dst_id)); - for (i = 0; i < nb_workstation; i++) - for (j = 0; j < nb_workstation; j++) - xbt_free(ROUTE(i,j).links); - xbt_free(routing_table); - routing_table = NULL; - nb_workstation = 0; + route->size = nb_link; + route->links = link_list = xbt_realloc(link_list, sizeof(link_KCCFLN05_t) * nb_link); + route->impact_on_src = impact_on_src; + route->impact_on_dst = impact_on_dst; + 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; - if (maxmin_system_network_KCCFLN05) { - lmm_system_free(maxmin_system_network_KCCFLN05); - maxmin_system_network_KCCFLN05 = NULL; - } } -static void network_KCCFLN05_resource_init_internal(void) +static int nb_link; +static int link_list_capacity; +static 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; +static int is_first = 1; + +static void parse_route_set_endpoints(void) { - s_surf_action_t action; + cpu_KCCFLN05_t cpu_tmp = NULL; - surf_network_resource = xbt_new0(s_surf_network_resource_t, 1); + if (is_first) create_routing_table(); + is_first = 0; - 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); + cpu_tmp = (cpu_KCCFLN05_t) name_service(A_surfxml_route_src); + if (cpu_tmp != NULL) { + src_id = cpu_tmp->id; + } else { + xbt_assert1(xbt_dict_get_or_null(router_set, A_surfxml_route_src), + "Invalid name '%s': neither a cpu nor a router!", + A_surfxml_route_src); + src_id = -1; + return; + } - 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)); + cpu_tmp = (cpu_KCCFLN05_t) name_service(A_surfxml_route_dst); + if (cpu_tmp != NULL) { + dst_id = cpu_tmp->id; + } else { + xbt_assert1(xbt_dict_get_or_null(router_set, A_surfxml_route_dst), + "Invalid name '%s': neither a cpu nor a router!", + A_surfxml_route_dst); + dst_id = -1; + return; + } - 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_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_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); - 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; + nb_link = 0; + link_list_capacity = 1; + link_list = xbt_new(link_KCCFLN05_t, link_list_capacity); - surf_network_resource->extension_public->communicate = communicate_KCCFLN05; +} - network_link_set = xbt_dict_new(); +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(link_KCCFLN05_t)); + } + TRY { + link_list[nb_link++] = + xbt_dict_get(link_set, A_surfxml_link_c_ctn_id); + } + CATCH(e) { + RETHROW1("Link %s not found (dict raised this exception: %s)", + A_surfxml_link_c_ctn_id); + } +} +static void parse_route_set_route(void) +{ + if (src_id != -1 && dst_id != -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); - maxmin_system_network_KCCFLN05 = lmm_system_new(); } -static void workstation_KCCFLN05_finalize(void) + +static void parse_file(const char *file) { - 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); + int i; - xbt_free(surf_workstation_resource->common_public); - xbt_free(surf_workstation_resource->common_private); - xbt_free(surf_workstation_resource->extension_public); + /* Adding callback functions */ + surf_parse_reset_parser(); + surfxml_add_callback(STag_surfxml_host_cb_list, &parse_cpu_init); + surfxml_add_callback(STag_surfxml_prop_cb_list, &parse_properties); + surfxml_add_callback(STag_surfxml_router_cb_list, &parse_routers); + surfxml_add_callback(STag_surfxml_link_cb_list, &parse_link_init); + surfxml_add_callback(STag_surfxml_route_cb_list, &parse_route_set_endpoints); + surfxml_add_callback(ETag_surfxml_link_c_ctn_cb_list, &parse_route_elem); + surfxml_add_callback(ETag_surfxml_route_cb_list, &parse_route_set_route); + + /* Parse the file */ + surf_parse_open(file); + xbt_assert1((!surf_parse()), "Parse error in %s", file); + surf_parse_close(); + + /* Adding loopback if needed */ + for (i = 0; i < nb_workstation; i++) + if (!ROUTE(i, i).size) { + if (!loopback) + loopback = link_new(xbt_strdup("__MSG_loopback__"), + 498000000, NULL, 0.000015, NULL, + SURF_LINK_ON, NULL, + SURF_LINK_FATPIPE, NULL); + ROUTE(i, i).size = 1; + ROUTE(i, i).links = xbt_new0(link_KCCFLN05_t, 1); + ROUTE(i, i).links[0] = loopback; + } - xbt_free(surf_workstation_resource); - surf_workstation_resource = NULL; } -static void workstation_KCCFLN05_resource_init_internal(void) +/**************************************/ +/********* Module creation ***********/ +/**************************************/ + +static void model_init_internal(void) { s_surf_action_t action; - surf_workstation_resource = xbt_new0(s_surf_workstation_resource_t, 1); + surf_workstation_model = xbt_new0(s_surf_workstation_model_t, 1); - surf_workstation_resource->common_private = - xbt_new0(s_surf_resource_private_t, 1); - surf_workstation_resource->common_public = - xbt_new0(s_surf_resource_public_t, 1); - surf_workstation_resource->extension_public = - xbt_new0(s_surf_workstation_resource_extension_public_t, 1); + surf_workstation_model->common_private = + xbt_new0(s_surf_model_private_t, 1); + surf_workstation_model->common_public = + xbt_new0(s_surf_model_public_t, 1); + surf_workstation_model->extension_public = + xbt_new0(s_surf_workstation_model_extension_public_t, 1); - surf_workstation_resource->common_public->states.ready_action_set = + surf_workstation_model->common_public->states.ready_action_set = xbt_swag_new(xbt_swag_offset(action, state_hookup)); - surf_workstation_resource->common_public->states.running_action_set = + surf_workstation_model->common_public->states.running_action_set = xbt_swag_new(xbt_swag_offset(action, state_hookup)); - surf_workstation_resource->common_public->states.failed_action_set = + surf_workstation_model->common_public->states.failed_action_set = xbt_swag_new(xbt_swag_offset(action, state_hookup)); - surf_workstation_resource->common_public->states.done_action_set = + surf_workstation_model->common_public->states.done_action_set = 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 = + surf_workstation_model->common_public->name_service = name_service; + surf_workstation_model->common_public->get_resource_name = get_resource_name; - surf_workstation_resource->common_public->action_get_state = + surf_workstation_model->common_public->action_get_state = surf_action_get_state; - surf_workstation_resource->common_public->action_free = action_free; - 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_set_data = surf_action_set_data; - 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->extension_public->execute = execute_KCCFLN05; -/*FIXME*//* surf_workstation_resource->extension_public->sleep = action_sleep; */ - surf_workstation_resource->extension_public->suspend = action_suspend; - surf_workstation_resource->extension_public->resume = action_resume; - surf_workstation_resource->extension_public->is_suspended = action_is_suspended; - surf_workstation_resource->extension_public->get_state = get_state; - surf_workstation_resource->extension_public->communicate = communicate_KCCFLN05; + surf_workstation_model->common_public->action_get_start_time = + surf_action_get_start_time; + surf_workstation_model->common_public->action_get_finish_time = + surf_action_get_finish_time; + surf_workstation_model->common_public->action_use = action_use; + surf_workstation_model->common_public->action_free = action_free; + surf_workstation_model->common_public->action_cancel = action_cancel; + surf_workstation_model->common_public->action_recycle = + action_recycle; + surf_workstation_model->common_public->action_change_state = + surf_action_change_state; + surf_workstation_model->common_public->action_set_data = + surf_action_set_data; + surf_workstation_model->common_public->suspend = action_suspend; + surf_workstation_model->common_public->resume = action_resume; + surf_workstation_model->common_public->is_suspended = + action_is_suspended; + surf_workstation_model->common_public->set_max_duration = + action_set_max_duration; + surf_workstation_model->common_public->set_priority = + action_set_priority; + surf_workstation_model->common_public->name = "Workstation KCCFLN05"; + + surf_workstation_model->common_private->resource_used = resource_used; + surf_workstation_model->common_private->share_resources = + share_resources; + surf_workstation_model->common_private->update_actions_state = + update_actions_state; + surf_workstation_model->common_private->update_resource_state = + update_resource_state; + surf_workstation_model->common_private->finalize = finalize; + + surf_workstation_model->extension_public->execute = execute; + surf_workstation_model->extension_public->sleep = action_sleep; + surf_workstation_model->extension_public->get_state = + resource_get_state; + surf_workstation_model->extension_public->get_speed = get_speed; + surf_workstation_model->extension_public->get_available_speed = + get_available_speed; + + surf_workstation_model->common_public->get_cpu_properties = get_cpu_properties; + surf_workstation_model->common_public->get_link_properties = get_link_properties; + + surf_workstation_model->extension_public->communicate = communicate; + surf_workstation_model->extension_public->execute_parallel_task = + execute_parallel_task; + surf_workstation_model->extension_public->get_route = get_route; + surf_workstation_model->extension_public->get_route_size = + get_route_size; + surf_workstation_model->extension_public->get_link_name = + get_link_name; + surf_workstation_model->extension_public->get_link_bandwidth = + get_link_bandwidth; + surf_workstation_model->extension_public->get_link_latency = + get_link_latency; + + workstation_set = xbt_dict_new(); + router_set = xbt_dict_new(); + link_set = xbt_dict_new(); + if (!maxmin_system) + maxmin_system = lmm_system_new(); } /**************************************/ /*************** Generic **************/ /**************************************/ - -void surf_workstation_resource_init_KCCFLN05(const char *filename) +void surf_workstation_model_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_model, "CPU model type already defined"); + xbt_assert0(!surf_network_model, + "network model type already defined"); + model_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; - } + xbt_dynar_push(model_list, &surf_workstation_model); }