X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/93aca7f5dc887d27c32e721953064501b10e662c..5f38fb0db35cabec94fef2da7563b82ef0adbb48:/src/surf/workstation.c diff --git a/src/surf/workstation.c b/src/surf/workstation.c index 352b760064..d16860c062 100644 --- a/src/surf/workstation.c +++ b/src/surf/workstation.c @@ -7,10 +7,15 @@ #include "xbt/ex.h" #include "xbt/dict.h" +#include "gras_config.h" #include "workstation_private.h" #include "cpu_private.h" #include "network_private.h" +#ifdef USE_GTNETS +#include "network_gtnets_private.h" +#endif + surf_workstation_resource_t surf_workstation_resource = NULL; xbt_dict_t workstation_set = NULL; static xbt_dict_t parallel_task_network_link_set = NULL; @@ -205,6 +210,69 @@ static void update_actions_state(double now, double delta) return; } +#ifdef USE_GTNETS +/* KF. For GTNetS. This is the same as surf_actions_state_gtnets except for + the network resource update. +*/ +static void update_actions_state_gtnets(double now, double delta) +{ + surf_action_parallel_task_CSL05_t action = NULL; + surf_action_parallel_task_CSL05_t next_action = NULL; + xbt_swag_t running_actions = + surf_workstation_resource->common_public->states.running_action_set; + /* FIXME: unused + xbt_swag_t failed_actions = + surf_workstation_resource->common_public->states.failed_action_set; + */ + + xbt_swag_foreach_safe(action, next_action, running_actions) { + double_update(&(action->generic_action.remains), + lmm_variable_getvalue(action->variable) * delta); + if (action->generic_action.max_duration != NO_MAX_DURATION) + double_update(&(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_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_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; + surf_resource_t resource = NULL; + + while ((cnst = + lmm_get_cnst_from_var(maxmin_system, action->variable, + i++))) { + resource = (surf_resource_t) lmm_constraint_id(cnst); + if(resource== (surf_resource_t) surf_cpu_resource) { + cpu_Cas01_t cpu = lmm_constraint_id(cnst); + if (cpu->state_current == SURF_CPU_OFF) { + action->generic_action.finish = surf_get_clock(); + action_change_state((surf_action_t) action, SURF_ACTION_FAILED); + break; + } + } else if (resource== (surf_resource_t) surf_network_resource) { + /** + network_link_GTNETS_t nw_link = lmm_constraint_id(cnst); + + if (nw_link->state_current == SURF_NETWORK_LINK_OFF) { + action->generic_action.finish = surf_get_clock(); + action_change_state((surf_action_t) action, SURF_ACTION_FAILED); + break; + } + **/ + } + } + } + } + + return; +} +#endif + static void update_resource_state(void *id, tmgr_trace_event_t event_type, double value) @@ -384,6 +452,101 @@ static surf_action_t execute_parallel_task (int workstation_nb, return (surf_action_t) action; } +#ifdef USE_GTNETS +/* KF. We don't support this for GTNetS. +*/ +static surf_action_t execute_parallel_task_gtnets (int workstation_nb, + void **workstation_list, + double *computation_amount, + double *communication_amount, + double amount, + double rate) +{ + xbt_assert0(0,"Cannot execute parallel task"); + return 0; +#if 0 + surf_action_parallel_task_CSL05_t action = NULL; + int i, j, k; + int nb_link = 0; + int nb_host = 0; + + if (parallel_task_network_link_set == NULL) { + parallel_task_network_link_set = xbt_dict_new_ext(workstation_nb * workstation_nb * 10); + } + + for(i=0; i< workstation_nb; i++) { + for(j=0; j< workstation_nb; j++) { + network_card_GTNETS_t card_src = ((workstation_CLM03_t*)workstation_list)[i]->network_card; + network_card_GTNETS_t card_dst = ((workstation_CLM03_t*)workstation_list)[j]->network_card; + int route_size = ROUTE_SIZE(card_src->id, card_dst->id); + network_link_GTNETS_t *route = ROUTE(card_src->id, card_dst->id); + + if(communication_amount[i*workstation_nb+j]>0) + for(k=0; k< route_size; k++) { + xbt_dict_set(parallel_task_network_link_set, route[k]->name, route[k], NULL); + } + } + } + + nb_link = xbt_dict_length(parallel_task_network_link_set); + xbt_dict_reset(parallel_task_network_link_set); + + for (i = 0; i0) nb_host++; + + if(nb_link + workstation_nb == 0) + return NULL; + + action = xbt_new0(s_surf_action_parallel_task_CSL05_t, 1); + action->generic_action.using = 1; + action->generic_action.cost = amount; + action->generic_action.remains = amount; + action->generic_action.max_duration = NO_MAX_DURATION; + action->generic_action.start = surf_get_clock(); + action->generic_action.finish = -1.0; + action->generic_action.resource_type = + (surf_resource_t) surf_workstation_resource; + action->suspended = 0; /* Should be useless because of the + calloc but it seems to help valgrind... */ + action->generic_action.state_set = + surf_workstation_resource->common_public->states.running_action_set; + + xbt_swag_insert(action, action->generic_action.state_set); + action->rate = rate; + + if(action->rate>0) + action->variable = lmm_variable_new(maxmin_system, action, 1.0, -1.0, + nb_host + nb_link); + else + action->variable = lmm_variable_new(maxmin_system, action, 1.0, action->rate, + nb_host + nb_link); + + for (i = 0; i0) + lmm_expand(maxmin_system, ((cpu_Cas01_t) ((workstation_CLM03_t) workstation_list[i])->cpu)->constraint, + action->variable, computation_amount[i]); + + for (i=0; inetwork_card; + network_card_GTNETS_t card_dst = ((workstation_CLM03_t*)workstation_list)[j]->network_card; + int route_size = ROUTE_SIZE(card_src->id, card_dst->id); + network_link_GTNETS_t *route = ROUTE(card_src->id, card_dst->id); + + for(k=0; k< route_size; k++) { + if(communication_amount[i*workstation_nb+j]>0) { + lmm_expand_add(maxmin_system, route[k]->constraint, + action->variable, communication_amount[i*workstation_nb+j]); + } + } + } + } + + return (surf_action_t) action; +#endif +} +#endif + /* returns an array of network_link_CM02_t */ static const void** get_route(void *src, void *dst) { workstation_CLM03_t workstation_src = (workstation_CLM03_t) src; @@ -502,6 +665,90 @@ static void surf_workstation_resource_init_internal(void) xbt_assert0(maxmin_system, "surf_init has to be called first!"); } +#ifdef USE_GTNETS +/* KF. For GTNetS. This is the same as surf_workstation_resource_init_internal + except for + - surf_workstation_resource->common_private->update_actions_state = + update_actions_state_gtnets; + - surf_workstation_resource->extension_public->execute_parallel_task = + execute_parallel_task_gtnets; +*/ +static void surf_workstation_resource_init_internal_gtnets(void) +{ + s_surf_action_t action; + + surf_workstation_resource = xbt_new0(s_surf_workstation_resource_t, 1); + + surf_workstation_resource->common_private = + xbt_new0(s_surf_resource_private_t, 1); + surf_workstation_resource->common_public = + xbt_new0(s_surf_resource_public_t, 1); +/* surf_workstation_resource->extension_private = xbt_new0(s_surf_workstation_resource_extension_private_t,1); */ + surf_workstation_resource->extension_public = + xbt_new0(s_surf_workstation_resource_extension_public_t, 1); + + surf_workstation_resource->common_public->states.ready_action_set = + xbt_swag_new(xbt_swag_offset(action, state_hookup)); + surf_workstation_resource->common_public->states.running_action_set = + xbt_swag_new(xbt_swag_offset(action, state_hookup)); + surf_workstation_resource->common_public->states.failed_action_set = + xbt_swag_new(xbt_swag_offset(action, state_hookup)); + surf_workstation_resource->common_public->states.done_action_set = + xbt_swag_new(xbt_swag_offset(action, state_hookup)); + + surf_workstation_resource->common_public->name_service = name_service; + surf_workstation_resource->common_public->get_resource_name = + get_resource_name; + surf_workstation_resource->common_public->action_get_state = + surf_action_get_state; + surf_workstation_resource->common_public->action_get_start_time = + surf_action_get_start_time; + surf_workstation_resource->common_public->action_get_finish_time = + surf_action_get_finish_time; + surf_workstation_resource->common_public->action_free = action_free; + surf_workstation_resource->common_public->action_use = action_use; + 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 = + action_change_state; + surf_workstation_resource->common_public->action_set_data = surf_action_set_data; + surf_workstation_resource->common_public->name = "Workstation"; + + 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_gtnets; + surf_workstation_resource->common_private->update_resource_state = + update_resource_state; + surf_workstation_resource->common_private->finalize = finalize; + + surf_workstation_resource->common_public->suspend = action_suspend; + surf_workstation_resource->common_public->resume = action_resume; + surf_workstation_resource->common_public->is_suspended = action_is_suspended; + surf_workstation_resource->common_public->set_max_duration = action_set_max_duration; + surf_workstation_resource->common_public->set_priority = action_set_priority; + + surf_workstation_resource->extension_public->execute = execute; + surf_workstation_resource->extension_public->sleep = action_sleep; + surf_workstation_resource->extension_public->get_state = 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_gtnets; + surf_workstation_resource->extension_public->get_route = get_route; + surf_workstation_resource->extension_public->get_route_size = get_route_size; + surf_workstation_resource->extension_public->get_link_name = get_link_name; + surf_workstation_resource->extension_public->get_link_bandwidth = get_link_bandwidth; + surf_workstation_resource->extension_public->get_link_latency = get_link_latency; + workstation_set = xbt_dict_new(); + + xbt_assert0(maxmin_system, "surf_init has to be called first!"); +} +#endif + /********************************************************************/ /* The model used in MSG and presented at CCGrid03 */ /********************************************************************/ @@ -536,3 +783,15 @@ void surf_workstation_resource_init_CLM03(const char *filename) /* } */ /* } */ } + +#ifdef USE_GTNETS +/* KF. Use GTNetS for the network. */ +void surf_workstation_resource_init_GTNETS(const char *filename) +{ + surf_workstation_resource_init_internal_gtnets(); + surf_cpu_resource_init_Cas01(filename); + surf_network_resource_init_GTNETS(filename); + create_workstations(); + xbt_dynar_push(resource_list, &surf_workstation_resource); +} +#endif