From: alegrand Date: Mon, 27 Mar 2006 11:19:32 +0000 (+0000) Subject: Complete rewriting of this workstation instance! I will tell more about it on the... X-Git-Tag: v3.3~3370 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/75cfb20f55fefdbc4639abaed9f511f33566a134 Complete rewriting of this workstation instance! I will tell more about it on the list in a while. git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@1988 48e7efb5-ca39-0410-a469-dd3cf9ba447f --- diff --git a/src/surf/workstation_KCCFLN05.c b/src/surf/workstation_KCCFLN05.c index 17ce526cc9..e59c7736df 100644 --- a/src/surf/workstation_KCCFLN05.c +++ b/src/surf/workstation_KCCFLN05.c @@ -12,203 +12,682 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(workstation_KCCFLN05, 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 network_link_set = NULL; + +/* convenient function */ +static void __update_cpu_usage(cpu_KCCFLN05_t cpu) +{ + 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 + ); + } +} /**************************************/ -/************* CPU object *************/ +/******* Resource Public **********/ /**************************************/ -/************ workstation creation *********/ -static void workstation_free(void *workstation) +static void *name_service(const char *name) { - 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); + return xbt_dict_get_or_null(workstation_set, name); } -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) +static const char *get_resource_name(void *resource_id) { - workstation_KCCFLN05_t workstation = xbt_new0(s_workstation_KCCFLN05_t, 1); + /* 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; +} - workstation->resource = (surf_resource_t) surf_workstation_resource; - workstation->name = xbt_strdup(name); - workstation->id = nb_workstation++; +/* action_get_state is inherited from the surf module */ - workstation->power_scale = power_scale; - xbt_assert0(workstation->power_scale>0,"Power has to be >0"); +static void action_use(surf_action_t action) +{ + action->using++; + return; +} - workstation->power_current = power_initial; - if (power_trace) - workstation->power_event = - tmgr_history_add_trace(history, power_trace, 0.0, 0, workstation); +static int action_free(surf_action_t action) +{ + 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; - workstation->state_current = state_initial; - if (state_trace) - workstation->state_event = - tmgr_history_add_trace(history, state_trace, 0.0, 0, workstation); + 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(!xbt_dynar_length(src->outgoing_communications)) + __update_cpu_usage(src); + } + if(dst) { + xbt_dynar_foreach(dst->incomming_communications, cpt, act) + if (act == action) { + xbt_dynar_remove_at(dst->incomming_communications, cpt, &act); + break; + } + if(!xbt_dynar_length(dst->incomming_communications)) + __update_cpu_usage(dst); + } + free(action); + return 1; + } + return 0; +} - workstation->interference_send=interference_send; - workstation->interference_recv=interference_recv; - workstation->interference_send_recv=interference_send_recv; +static void action_cancel(surf_action_t action) +{ + surf_action_change_state(action, SURF_ACTION_FAILED); + return; +} - 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); +static void action_recycle(surf_action_t action) +{ + DIE_IMPOSSIBLE; + return; +} - 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); +/* action_change_state is inherited from the surf module */ +/* action_set_data is inherited from the surf module */ - xbt_dict_set(workstation_set, name, workstation, workstation_free); +static void action_suspend(surf_action_t action) +{ + XBT_IN1("(%p))",action); + lmm_update_variable_weight(maxmin_system, + ((surf_action_workstation_KCCFLN05_t) + action)->variable, 0.0); + XBT_OUT; +} - return workstation; +static void action_resume(surf_action_t action) +{ + XBT_IN1("(%p)",action); + lmm_update_variable_weight(maxmin_system, + ((surf_action_workstation_KCCFLN05_t) + action)->variable, 1.0); + XBT_OUT; } -static void parse_workstation(void) +static int action_is_suspended(surf_action_t action) { - 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; + return (lmm_get_variable_weight + (((surf_action_workstation_KCCFLN05_t) action)->variable) == + 0.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); +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; +} - 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); - - workstation_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_set_priority(surf_action_t action, double priority) +{ /* FIXME: should inherit */ + XBT_IN2("(%p,%g)",action,priority); + action->priority = priority; + XBT_OUT; } -/*********** resource management ***********/ +/**************************************/ +/******* Resource Private **********/ +/**************************************/ -static void *name_service(const char *name) +static int resource_used(void *resource_id) { - return xbt_dict_get_or_null(workstation_set, name); + /* 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) || + lmm_constraint_used(maxmin_system, + ((cpu_KCCFLN05_t) resource_id)-> + bus)); + else + return lmm_constraint_used(maxmin_system, + ((network_link_KCCFLN05_t) resource_id)-> + constraint); + } -static const char *get_resource_name(void *resource_id) +static double share_resources(double now) +{ + 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; + else if (action->latencylatency; + } + } + + return min; +/* return generic_maxmin_share_resources(surf_workstation_resource->common_public-> */ +/* states.running_action_set, */ +/* xbt_swag_offset(action, variable)); */ +} + +static void update_actions_state(double now, double delta) +{ + 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_resource->common_public->states.running_action_set; + + xbt_swag_foreach_safe(action, next_action, running_actions) { + deltap = delta; + if (action->latency > 0) { + if (action->latency > deltap) { + surf_double_update(&(action->latency), deltap); + deltap = 0.0; + } else { + surf_double_update(&(deltap), action->latency); + action->latency = 0.0; + } + if ((action->latency == 0.0) && !(action->suspended)) + lmm_update_variable_weight(maxmin_system, action->variable, 1.0); + } + surf_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<.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(); + 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; + + 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 void update_resource_state(void *id, + tmgr_trace_event_t event_type, + double value) +{ + 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))); + } + } 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; +} + +static void finalize(void) +{ + int i,j; + + xbt_dict_free(&network_link_set); + xbt_dict_free(&workstation_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); + + free(surf_workstation_resource->common_public); + free(surf_workstation_resource->common_private); + free(surf_workstation_resource->extension_public); + + free(surf_workstation_resource); + surf_workstation_resource = 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; + + if (maxmin_system) { + lmm_system_free(maxmin_system); + maxmin_system = NULL; + } +} + +/**************************************/ +/******* Resource Private **********/ +/**************************************/ + +static surf_action_t execute(void *cpu, double size) { - return ((workstation_KCCFLN05_t) resource_id)->name; + surf_action_workstation_KCCFLN05_t action = NULL; + cpu_KCCFLN05_t CPU = cpu; + + XBT_IN2("(%s,%g)",CPU->name,size); + 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.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; + + 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); + + 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 int cpu_used(void *resource_id) +static surf_action_t action_sleep(void *cpu, double duration) { - return lmm_constraint_used(maxmin_system_cpu_KCCFLN05, - ((workstation_KCCFLN05_t) resource_id)->constraint); + 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; + lmm_update_variable_weight(maxmin_system, action->variable, 0.0); + + XBT_OUT; + return (surf_action_t) action; } -static int link_used(void *resource_id) +static e_surf_cpu_state_t resource_get_state(void *cpu) { - return lmm_constraint_used(maxmin_system_network_KCCFLN05, - ((network_link_KCCFLN05_t) resource_id)->constraint); + return ((cpu_KCCFLN05_t) cpu)->state_current; } -static e_surf_cpu_state_t get_state(void *cpu) +static double get_speed(void *cpu, double load) { - return ((workstation_KCCFLN05_t) cpu)->state_current; + return load*(((cpu_KCCFLN05_t) cpu)->power_scale); } -static void update_cpu_KCCFLN05_state(void *id, - tmgr_trace_event_t event_type, - double value) +static surf_action_t communicate(void *src, void *dst, double size, double rate) { - 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; + 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_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.finish = -1.0; + action->src = src; + action->dst = dst; + 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_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 - cpu->state_current = SURF_CPU_OFF; + lmm_update_variable_bound(maxmin_system, action->variable, -1.0); } else { - CRITICAL0("Unknown event ! \n"); - xbt_abort(); + 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); } - return; + 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; +} + +/* FIXME: execute_parallel_task */ +static surf_action_t execute_parallel_task(int cpu_nb, + void **cpu_list, + double *computation_amount, + double *communication_amount, + double amount, + double rate) +{ + DIE_IMPOSSIBLE; + return NULL; } + /**************************************/ -/*********** network object ***********/ +/*** Resource Creation & Destruction **/ /**************************************/ +static void cpu_free(void *cpu) +{ + 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 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) +{ + 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 parse_cpu(void) +{ + 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 create_routing_table(void) { - routing_table = xbt_new0(s_route_KCCFLN05_t, nb_workstation * nb_workstation); + routing_table = + xbt_new0(s_route_KCCFLN05_t, nb_workstation * nb_workstation); } static void network_link_free(void *nw_link) { - free(((network_link_KCCFLN05_t)nw_link)->name); + free(((network_link_KCCFLN05_t) nw_link)->name); free(nw_link); } 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) + 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) { network_link_KCCFLN05_t nw_link = xbt_new0(s_network_link_KCCFLN05_t, 1); - nw_link->resource = (surf_resource_t) surf_network_resource; + 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_network_KCCFLN05, nw_link, nw_link->bw_current); + lmm_constraint_new(maxmin_system, nw_link, nw_link->bw_current); + + if(policy == SURF_NETWORK_LINK_FATPIPE) + lmm_constraint_shared(nw_link->constraint); xbt_dict_set(network_link_set, name, nw_link, network_link_free); @@ -220,23 +699,36 @@ static void parse_network_link(void) 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; 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); 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; - if (A_surfxml_network_link_state==A_surfxml_network_link_state_OFF) + else if (A_surfxml_network_link_state==A_surfxml_network_link_state_OFF) state_initial = SURF_NETWORK_LINK_OFF; + + 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_parse_get_trace(&state_trace,A_surfxml_network_link_state_file); - network_link_new(name, bw_initial, bw_trace, state_initial, state_trace); + network_link_new(name, bw_initial, bw_trace, + lat_initial, lat_trace, state_initial, state_trace, + policy_initial); } static void route_new(int src_id, int dst_id, char **links, int nb_link, @@ -246,19 +738,19 @@ static void route_new(int src_id, int dst_id, char **links, int nb_link, { network_link_KCCFLN05_t *link_list = NULL; int i; - route_KCCFLN05_t route = &(ROUTE(src_id,dst_id)); + route_KCCFLN05_t route = &(ROUTE(src_id, dst_id)); - route->size= nb_link; + route->size = nb_link; link_list = route->links = xbt_new0(network_link_KCCFLN05_t, nb_link); for (i = 0; i < nb_link; i++) { link_list[i] = xbt_dict_get_or_null(network_link_set, links[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; + 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; } static int nb_link = 0; @@ -267,17 +759,19 @@ 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_src_with_other_recv; static double impact_on_dst_with_other_send; static void parse_route_set_endpoints(void) { - src_id = ((workstation_KCCFLN05_t) name_service(A_surfxml_route_src))->id; - dst_id = ((workstation_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); + 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); nb_link = 0; link_name = NULL; @@ -292,743 +786,64 @@ static void parse_route_elem(void) 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); + 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); } static void parse_file(const char *file) { - /* Figuring out the workstations */ + int i ; + + /* Figuring out the cpus */ surf_parse_reset_parser(); - ETag_surfxml_cpu_fun=parse_workstation; + ETag_surfxml_cpu_fun = parse_cpu; surf_parse_open(file); - xbt_assert1((!surf_parse()),"Parse error in %s",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_surfxml_network_link_fun=parse_network_link; + ETag_surfxml_network_link_fun = parse_network_link; surf_parse_open(file); - xbt_assert1((!surf_parse()),"Parse error in %s",file); + xbt_assert1((!surf_parse()), "Parse error in %s", file); surf_parse_close(); /* 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; + 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); + xbt_assert1((!surf_parse()), "Parse error in %s", file); surf_parse_close(); -} -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(); - } + /* 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__"), + 498.00, 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; + } - return; } /**************************************/ -/*************** actions **************/ +/********* Module creation ***********/ /**************************************/ -/*************** network **************/ -static int action_network_KCCFLN05_free(surf_action_t action) + +static void resource_init_internal(void) { - 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; + s_surf_action_t action; - 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) -{ - action->using++; -} - -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) -{ - 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; - } - } - - 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; -} - -static void update_actions_network_KCCFLN05_state(double now, double delta) -{ - 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; - /* FIXME: unused - xbt_swag_t failed_actions = - surf_network_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) - surf_double_update(&(action->generic_action.max_duration), delta); - if ((action->generic_action.remains <= 0.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.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; -} - -static surf_action_t communicate_KCCFLN05(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); - int i; - - 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_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); - - for (i = 0; i < route->size; i++) - lmm_expand(maxmin_system_network_KCCFLN05, route->links[i]->constraint, - action->variable, 1.0); - - if(card_src->bus) - lmm_expand(maxmin_system_network_KCCFLN05, card_src->bus, - 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); - - return (surf_action_t) action; -} - -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; -} - -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); -} - -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); -} - -static int network_KCCFLN05_action_is_suspended(surf_action_t action) -{ - return (lmm_get_variable_weight(((surf_action_network_KCCFLN05_t) action)->variable) == 0.0); -} - -static void network_KCCFLN05_action_set_max_duration(surf_action_t action, double duration) -{ - action->max_duration = duration; -} - -/***************** 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; -} - -static void action_cpu_KCCFLN05_use(surf_action_t action) -{ - action->using++; -} - -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; -} - -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; - - if(surf_get_clock()>=475.895) - { - W=0.0; - } - - 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); - } - - 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; - */ - - 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; - - 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; - } - } - } - } - - return; -} - -static surf_action_t execute_KCCFLN05(void *cpu, double size) -{ - 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.using = 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; - - 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; -} - -static void cpu_KCCFLN05_action_suspend(surf_action_t action) -{ - lmm_update_variable_weight(maxmin_system_cpu_KCCFLN05, - ((surf_action_cpu_KCCFLN05_t) action)->variable, 0.0); -} - -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); -} - -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 void cpu_KCCFLN05_action_set_max_duration(surf_action_t action, double duration) -{ - action->max_duration = duration; -} - -/************* 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 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 void action_use(surf_action_t action) -{ - 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; -} - -static int resource_used(void *resource_id) -{ - xbt_assert0(0, "Workstation is a virtual resource. I should not be there!"); - return 0; -} - -static double share_resources(double now) -{ - return -1.0; -} - -static void update_actions_state(double now, double delta) -{ - return; -} - -static void update_resource_state(void *id, - tmgr_trace_event_t event_type, - double value) -{ - xbt_assert0(0, "Workstation is a virtual resource. I should not be there!"); - return; -} - -static void action_suspend(surf_action_t action) -{ - 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; -} - -static void action_resume(surf_action_t action) -{ - 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; -} - -static int action_is_suspended(surf_action_t action) -{ - 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; -} - -static void action_set_max_duration(surf_action_t action, double duration) -{ - 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; -} - - -/**************************************/ -/********* 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); - - 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; - } -} - -static void cpu_KCCFLN05_resource_init_internal(void) -{ - s_surf_action_t action; - - 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); - - surf_cpu_resource->extension_public = - xbt_new0(s_surf_cpu_resource_extension_public_t, 1); - - 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_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(); -} - -static void network_KCCFLN05_finalize(void) -{ - int i,j; - - 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); - - free(surf_network_resource); - surf_network_resource = 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; - - 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) -{ - s_surf_action_t action; - - surf_network_resource = xbt_new0(s_surf_network_resource_t, 1); - - 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); - - 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)); - - 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; - - network_link_set = xbt_dict_new(); - - maxmin_system_network_KCCFLN05 = lmm_system_new(); -} - -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); - - free(surf_workstation_resource->common_public); - free(surf_workstation_resource->common_private); - free(surf_workstation_resource->extension_public); - - free(surf_workstation_resource); - surf_workstation_resource = NULL; -} - -static void workstation_KCCFLN05_resource_init_internal(void) -{ - s_surf_action_t action; - - surf_workstation_resource = xbt_new0(s_surf_workstation_resource_t, 1); + surf_workstation_resource = xbt_new0(s_surf_workstation_resource_t, 1); surf_workstation_resource->common_private = xbt_new0(s_surf_resource_private_t, 1); @@ -1047,58 +862,48 @@ 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_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_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->communicate = communicate; + surf_workstation_resource->extension_public->execute_parallel_task = execute_parallel_task; - 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; + workstation_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; - } } diff --git a/src/surf/workstation_KCCFLN05_private.h b/src/surf/workstation_KCCFLN05_private.h index e7f1c75071..458808a4aa 100644 --- a/src/surf/workstation_KCCFLN05_private.h +++ b/src/surf/workstation_KCCFLN05_private.h @@ -10,13 +10,20 @@ #include "surf_private.h" +typedef enum { + SURF_WORKSTATION_RESOURCE_CPU, + SURF_WORKSTATION_RESOURCE_LINK, +} e_surf_workstation_resource_type_t; + /**************************************/ -/********* workstation object *********/ +/********* cpu object *****************/ /**************************************/ -typedef struct workstation_KCCFLN05 { - surf_resource_t resource; /* Any such object, added in a trace - should start by this field!!! */ - char *name; +typedef struct cpu_KCCFLN05 { + surf_resource_t resource; + e_surf_workstation_resource_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; @@ -25,33 +32,33 @@ typedef struct workstation_KCCFLN05 { tmgr_trace_event_t power_event; e_surf_cpu_state_t state_current; tmgr_trace_event_t state_event; - lmm_constraint_t constraint; - int id; /* cpu and network card are a single object... */ + int id; /* cpu and network card are a single object... */ xbt_dynar_t incomming_communications; xbt_dynar_t outgoing_communications; - lmm_constraint_t bus; -} s_workstation_KCCFLN05_t, *workstation_KCCFLN05_t; +} s_cpu_KCCFLN05_t, *cpu_KCCFLN05_t; /**************************************/ /*********** network object ***********/ /**************************************/ typedef struct network_link_KCCFLN05 { - surf_resource_t resource; /* Any such object, added in a trace - should start by this field!!! */ - char *name; + surf_resource_t resource; + e_surf_workstation_resource_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_network_link_state_t state_current; tmgr_trace_event_t state_event; - lmm_constraint_t constraint; } s_network_link_KCCFLN05_t, *network_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_src_with_other_recv; double impact_on_dst_with_other_send; network_link_KCCFLN05_t *links; int size; @@ -60,18 +67,16 @@ typedef struct s_route_KCCFLN05 { /**************************************/ /*************** actions **************/ /**************************************/ - -typedef struct surf_action_cpu_KCCFLN05 { - s_surf_action_t generic_action; - lmm_variable_t variable; -} s_surf_action_cpu_KCCFLN05_t, *surf_action_cpu_KCCFLN05_t; - -typedef struct surf_action_network_KCCFLN05 { +typedef struct surf_action_workstation_KCCFLN05 { s_surf_action_t generic_action; + double latency; + double lat_current; lmm_variable_t variable; - workstation_KCCFLN05_t src; - workstation_KCCFLN05_t dst; -} s_surf_action_network_KCCFLN05_t, *surf_action_network_KCCFLN05_t; - + 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; #endif /* _SURF_WORKSTATION_KCCFLN05_PRIVATE_H */