X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/e73dc2efae11f86d0054e1a3f08eee1a0ca5797f..3cc98de394c2f860157a7a1dbb8b48d95de0fbc8:/src/surf/workstation.c diff --git a/src/surf/workstation.c b/src/surf/workstation.c index 2f4aef5263..ccca24483c 100644 --- a/src/surf/workstation.c +++ b/src/surf/workstation.c @@ -5,17 +5,16 @@ /* 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 "gras_config.h" #include "workstation_private.h" #include "cpu_private.h" #include "network_private.h" -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(workstation, surf, - "Logging specific to the SURF workstation module"); - surf_workstation_resource_t surf_workstation_resource = NULL; - xbt_dict_t workstation_set = NULL; +static xbt_dict_t parallel_task_network_link_set = NULL; static workstation_CLM03_t workstation_new(const char *name, void *cpu, void *card) @@ -38,15 +37,16 @@ static void workstation_free(void *workstation) static void create_workstations(void) { - xbt_dict_cursor_t cursor = NULL; + xbt_dict_cursor_t cursor = NULL; char *name = NULL; void *cpu = NULL; void *nw_card = NULL; xbt_dict_foreach(cpu_set, cursor, name, cpu) { - nw_card = NULL; - xbt_dict_get(network_card_set, name, (void *) &nw_card); - xbt_assert1(nw_card, "No corresponding card found for %s",name); + nw_card = xbt_dict_get_or_null(network_card_set, name); + xbt_assert1(nw_card, + "No corresponding card found for %s",name); + xbt_dict_set(workstation_set, name, workstation_new(name, cpu, nw_card), workstation_free); } @@ -54,11 +54,7 @@ static void create_workstations(void) static void *name_service(const char *name) { - void *workstation = NULL; - - xbt_dict_get(workstation_set, name, &workstation); - - return workstation; + return xbt_dict_get_or_null(workstation_set, name); } static const char *get_resource_name(void *resource_id) @@ -110,14 +106,20 @@ static void action_use(surf_action_t action) else if(action->resource_type==(surf_resource_t)surf_cpu_resource) surf_cpu_resource->common_public->action_use(action); else if(action->resource_type==(surf_resource_t)surf_workstation_resource) - return parallel_action_use(action); + parallel_action_use(action); else DIE_IMPOSSIBLE; return; } static void action_cancel(surf_action_t action) { - DIE_IMPOSSIBLE; + if(action->resource_type==(surf_resource_t)surf_network_resource) + surf_network_resource->common_public->action_cancel(action); + else if(action->resource_type==(surf_resource_t)surf_cpu_resource) + surf_cpu_resource->common_public->action_cancel(action); + else if(action->resource_type==(surf_resource_t)surf_workstation_resource) + parallel_action_use(action); + else DIE_IMPOSSIBLE; return; } @@ -154,14 +156,16 @@ static void update_actions_state(double now, double delta) 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) { - surf_double_update(&(action->generic_action.remains), + 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); + 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(); @@ -256,6 +260,15 @@ static void action_set_max_duration(surf_action_t action, double duration) surf_cpu_resource->common_public->set_max_duration(action,duration); else DIE_IMPOSSIBLE; } + +static void action_set_priority(surf_action_t action, double priority) +{ + if(action->resource_type==(surf_resource_t)surf_network_resource) + surf_network_resource->common_public->set_priority(action,priority); + else if(action->resource_type==(surf_resource_t)surf_cpu_resource) + surf_cpu_resource->common_public->set_priority(action,priority); + else DIE_IMPOSSIBLE; +} static surf_action_t communicate(void *workstation_src, void *workstation_dst, double size, @@ -272,6 +285,28 @@ static e_surf_cpu_state_t get_state(void *workstation) get_state(((workstation_CLM03_t) workstation)->cpu); } +static double get_speed(void *workstation, double load) +{ + return surf_cpu_resource->extension_public-> + get_speed(((workstation_CLM03_t) workstation)->cpu, load); +} + +static double get_available_speed(void *workstation) +{ + return surf_cpu_resource->extension_public-> + get_available_speed(((workstation_CLM03_t) workstation)->cpu); +} + +static surf_action_t execute_parallel_task_bogus (int workstation_nb, + void **workstation_list, + double *computation_amount, + double *communication_amount, + double amount, + double rate) +{ + xbt_assert0(0,"This model does not implement parallel tasks"); +} + static surf_action_t execute_parallel_task (int workstation_nb, void **workstation_list, double *computation_amount, @@ -281,12 +316,12 @@ static surf_action_t execute_parallel_task (int workstation_nb, { surf_action_parallel_task_CSL05_t action = NULL; int i, j, k; - xbt_dict_t network_link_set = xbt_dict_new(); - xbt_dict_cursor_t cursor = NULL; - char *name = NULL; int nb_link = 0; int nb_host = 0; - network_link_CM02_t link; + + if (parallel_task_network_link_set == NULL) { + parallel_task_network_link_set = xbt_dict_new_ext(workstation_nb * workstation_nb * 10); + } /* Compute the number of affected resources... */ for(i=0; i< workstation_nb; i++) { @@ -298,16 +333,13 @@ static surf_action_t execute_parallel_task (int workstation_nb, if(communication_amount[i*workstation_nb+j]>0) for(k=0; k< route_size; k++) { - xbt_dict_set(network_link_set, route[k]->name, route[k], NULL); + xbt_dict_set(parallel_task_network_link_set, route[k]->name, route[k], NULL); } } } - xbt_dict_foreach(network_link_set, cursor, name, link) { - nb_link++; - } - - xbt_dict_free(&network_link_set); + nb_link = xbt_dict_length(parallel_task_network_link_set); + xbt_dict_reset(parallel_task_network_link_set); for (i = 0; i0) nb_host++; @@ -320,7 +352,7 @@ static surf_action_t execute_parallel_task (int workstation_nb, action->generic_action.cost = amount; action->generic_action.remains = amount; action->generic_action.max_duration = NO_MAX_DURATION; - action->generic_action.start = -1.0; + action->generic_action.start = surf_get_clock(); action->generic_action.finish = -1.0; action->generic_action.resource_type = (surf_resource_t) surf_workstation_resource; @@ -363,6 +395,31 @@ static surf_action_t execute_parallel_task (int workstation_nb, return (surf_action_t) action; } +/* 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; + workstation_CLM03_t workstation_dst = (workstation_CLM03_t) dst; + return surf_network_resource->extension_public->get_route(workstation_src->network_card, workstation_dst->network_card); +} + +static int get_route_size(void *src, void *dst) { + workstation_CLM03_t workstation_src = (workstation_CLM03_t) src; + workstation_CLM03_t workstation_dst = (workstation_CLM03_t) dst; + return surf_network_resource->extension_public->get_route_size(workstation_src->network_card, workstation_dst->network_card); +} + +static const char *get_link_name(const void *link) { + return surf_network_resource->extension_public->get_link_name(link); +} + +static double get_link_bandwidth(const void *link) { + return surf_network_resource->extension_public->get_link_bandwidth(link); +} + +static double get_link_latency(const void *link) { + return surf_network_resource->extension_public->get_link_latency(link); +} + static void finalize(void) { xbt_dict_free(&workstation_set); @@ -409,6 +466,10 @@ static void surf_workstation_resource_init_internal(void) 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; @@ -432,14 +493,21 @@ static void surf_workstation_resource_init_internal(void) 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; - + execute_parallel_task_bogus; + 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!"); @@ -458,24 +526,29 @@ static void surf_workstation_resource_init_internal(void) /* } */ void surf_workstation_resource_init_CLM03(const char *filename) { -/* int i ; */ -/* surf_resource_t resource = NULL; */ - surf_workstation_resource_init_internal(); surf_cpu_resource_init_Cas01(filename); surf_network_resource_init_CM02(filename); create_workstations(); + update_resource_description(surf_workstation_resource_description, + surf_workstation_resource_description_size, + "CLM03", + (surf_resource_t) surf_workstation_resource); + xbt_dynar_push(resource_list, &surf_workstation_resource); +} + +void surf_workstation_resource_init_compound(const char *filename) +{ + + xbt_assert0(surf_cpu_resource,"No CPU resource defined yet!"); + xbt_assert0(surf_network_resource,"No network resource defined yet!"); + surf_workstation_resource_init_internal(); + create_workstations(); + + update_resource_description(surf_workstation_resource_description, + surf_workstation_resource_description_size, + "compound", + (surf_resource_t) surf_workstation_resource); + xbt_dynar_push(resource_list, &surf_workstation_resource); -/* xbt_dynar_foreach(resource_list, i, resource) { */ -/* if(resource==surf_cpu_resource) { */ -/* xbt_dynar_remove_at(resource_list, i, NULL); */ -/* i--; */ -/* continue; */ -/* } */ -/* if(resource==surf_network_resource) { */ -/* xbt_dynar_remove_at(resource_list, i, NULL); */ -/* i--; */ -/* continue; */ -/* } */ -/* } */ }