X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/ade56d3398a38946ba60efdd3000e5b6c9d053ed..688697437ee29632f93998b1d41fcc0f8cb9faee:/src/surf/workstation_KCCFLN05.c diff --git a/src/surf/workstation_KCCFLN05.c b/src/surf/workstation_KCCFLN05.c index b18b36cda6..c91ad04542 100644 --- a/src/surf/workstation_KCCFLN05.c +++ b/src/surf/workstation_KCCFLN05.c @@ -5,213 +5,722 @@ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ +#include "xbt/ex.h" #include "xbt/dict.h" #include "workstation_KCCFLN05_private.h" -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(workstation_KCCFLN05, surf, +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_workstation, surf, "Logging specific to the SURF workstation module (KCCFLN05)"); - -static lmm_system_t maxmin_system_cpu_KCCFLN05 = NULL; -static lmm_system_t maxmin_system_network_KCCFLN05 = NULL; -static xbt_dict_t network_link_set = NULL; static int nb_workstation = 0; -s_route_KCCFLN05_t *routing_table = NULL; +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; + +/*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(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 void action_cancel(surf_action_t action) +{ + surf_action_change_state(action, SURF_ACTION_FAILED); + return; +} - workstation->interference_send=interference_send; - workstation->interference_recv=interference_recv; - workstation->interference_send_recv=interference_send_recv; +static void action_recycle(surf_action_t action) +{ + DIE_IMPOSSIBLE; + 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); +/* action_change_state is inherited from the surf module */ +/* action_set_data is inherited from the surf module */ - 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); +static void action_suspend(surf_action_t action) +{ + XBT_IN1("(%p))",action); + ((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; +} - xbt_dict_set(workstation_set, name, workstation, workstation_free); +static void action_resume(surf_action_t action) +{ + XBT_IN1("(%p)",action); + if(((surf_action_workstation_KCCFLN05_t)action)->lat_current==0.0) + lmm_update_variable_weight(maxmin_system, + ((surf_action_workstation_KCCFLN05_t) + action)->variable, 1.0); + else + lmm_update_variable_weight(maxmin_system, + ((surf_action_workstation_KCCFLN05_t) action)->variable, + ((surf_action_workstation_KCCFLN05_t) action)->lat_current); - return workstation; + ((surf_action_workstation_KCCFLN05_t) action)->suspended = 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 (((surf_action_workstation_KCCFLN05_t) action)->suspended); +} - surf_parse_get_double(&power_scale,A_cpu_power); - surf_parse_get_double(&power_initial,A_cpu_availability); - surf_parse_get_trace(&power_trace,A_cpu_availability_file); - - xbt_assert0((A_cpu_state==A_cpu_state_ON)|| - (A_cpu_state==A_cpu_state_OFF), - "Invalid state") - if (A_cpu_state==A_cpu_state_ON) state_initial = SURF_CPU_ON; - if (A_cpu_state==A_cpu_state_OFF) state_initial = SURF_CPU_OFF; - surf_parse_get_trace(&state_trace,A_cpu_state_file); - - surf_parse_get_double(&interference_send,A_cpu_interference_send); - surf_parse_get_double(&interference_recv,A_cpu_interference_recv); - surf_parse_get_double(&interference_send_recv,A_cpu_interference_send_recv); - surf_parse_get_double(&max_outgoing_rate,A_cpu_max_outgoing_rate); - - workstation_new(A_cpu_name, power_scale, power_initial, power_trace, state_initial, - state_trace, interference_send, interference_recv, - interference_send_recv, max_outgoing_rate); +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; } -/*********** resource management ***********/ -static void *name_service(const char *name) +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 Private **********/ +/**************************************/ + +static int resource_used(void *resource_id) +{ + /* We can freely cast as a network_link_KCCFLN05_t because it has + the same prefix as cpu_KCCFLN05_t */ + if(((cpu_KCCFLN05_t) resource_id)->type == SURF_WORKSTATION_RESOURCE_CPU) + return (lmm_constraint_used(maxmin_system, + ((cpu_KCCFLN05_t) resource_id)-> + constraint) || + ((((cpu_KCCFLN05_t) resource_id)->bus)? + lmm_constraint_used(maxmin_system, + ((cpu_KCCFLN05_t) resource_id)-> + bus):0)); + else + return lmm_constraint_used(maxmin_system, + ((network_link_KCCFLN05_t) resource_id)-> + constraint); + +} + +static double share_resources(double now) { - void *workstation = NULL; + 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_dict_get(workstation_set, name, &workstation); + xbt_swag_foreach(action, running_actions) { + if(action->latency>0) { + if(min<0) min = action->latency; + else if (action->latencylatency; + } + } - return workstation; + return min; +/* return generic_maxmin_share_resources(surf_workstation_resource->common_public-> */ +/* states.running_action_set, */ +/* xbt_swag_offset(action, variable)); */ } -static const char *get_resource_name(void *resource_id) +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)) { + 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); + } + } + 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))); + if(!(action->suspended)) + lmm_update_variable_weight(maxmin_system, action->variable, + 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) +{ + 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; + action->suspended = 0; + + 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 surf_action_t action_sleep(void *cpu, double duration) { - return ((workstation_KCCFLN05_t) resource_id)->name; + 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 cpu_used(void *resource_id) +static e_surf_cpu_state_t resource_get_state(void *cpu) { - return lmm_constraint_used(maxmin_system_cpu_KCCFLN05, - ((workstation_KCCFLN05_t) resource_id)->constraint); + return ((cpu_KCCFLN05_t) cpu)->state_current; } -static int link_used(void *resource_id) +static double get_speed(void *cpu, double load) { - return lmm_constraint_used(maxmin_system_network_KCCFLN05, - ((network_link_KCCFLN05_t) resource_id)->constraint); + return load*(((cpu_KCCFLN05_t) cpu)->power_scale); } -static e_surf_cpu_state_t get_state(void *cpu) +static double get_available_speed(void *cpu) { - return ((workstation_KCCFLN05_t) cpu)->state_current; + return ((cpu_KCCFLN05_t) cpu)->power_current; } -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; +} + +/* returns a NULL-terminated array of network_link_KCCFLN05_t */ +static const void** get_route(void *src, void *dst) { + cpu_KCCFLN05_t card_src = src; + cpu_KCCFLN05_t card_dst = dst; + route_KCCFLN05_t route = &(ROUTE(card_src->id, card_dst->id)); + int route_size = route->size; + + /* add NULL at the end of the array if not present */ + route->links = xbt_realloc(route->links, (route_size+1) * sizeof(route_KCCFLN05_t)); + route->links[route_size] = NULL; + + return (const void**) route->links; } /**************************************/ -/*********** 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); @@ -223,23 +732,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_network_link_name); - surf_parse_get_double(&bw_initial,A_network_link_bandwidth); - surf_parse_get_trace(&bw_trace, A_network_link_bandwidth_file); + 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_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) + 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_network_link_state==A_network_link_state_OFF) + else if (A_surfxml_network_link_state==A_surfxml_network_link_state_OFF) state_initial = SURF_NETWORK_LINK_OFF; - surf_parse_get_trace(&state_trace,A_network_link_state_file); - network_link_new(name, bw_initial, bw_trace, state_initial, state_trace); + 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, + 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, @@ -249,19 +771,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++) { - xbt_dict_get(network_link_set, links[i], (void *) &(link_list[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; @@ -270,17 +792,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_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); + 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; @@ -290,721 +814,69 @@ static void parse_route_elem(void) { nb_link++; link_name = xbt_realloc(link_name, (nb_link) * sizeof(char *)); - link_name[(nb_link) - 1] = xbt_strdup(A_route_element_name); + link_name[(nb_link) - 1] = xbt_strdup(A_surfxml_route_element_name); } 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_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_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_route_fun=parse_route_set_endpoints; - ETag_route_element_fun=parse_route_elem; - ETag_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 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; - 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; - - 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 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_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) - return surf_network_resource->common_public->set_max_duration(action,duration); - if(action->resource_type==(surf_resource_t)surf_cpu_resource) - return surf_cpu_resource->common_public->set_max_duration(action,duration); - 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_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_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); @@ -1023,55 +895,51 @@ 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->get_speed = get_speed; + surf_workstation_resource->extension_public->get_available_speed = get_available_speed; + surf_workstation_resource->extension_public->communicate = communicate; + surf_workstation_resource->extension_public->execute_parallel_task = execute_parallel_task; + surf_workstation_resource->extension_public->get_route = get_route; - surf_workstation_resource->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; + workstation_set = xbt_dict_new(); + network_link_set = xbt_dict_new(); - 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; + 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; - } }