From: mquinson Date: Wed, 14 Apr 2010 16:41:25 +0000 (+0000) Subject: Add a Vivaldi network model, coded live during SUD'10 ;) X-Git-Tag: SVN~173 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/5de55298b58930e1c9f0d92bafa39e91ce55fc05 Add a Vivaldi network model, coded live during SUD'10 ;) git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@7568 48e7efb5-ca39-0410-a469-dd3cf9ba447f --- diff --git a/ChangeLog b/ChangeLog index 048bf58ef3..f06b23390b 100644 --- a/ChangeLog +++ b/ChangeLog @@ -100,6 +100,7 @@ SimGrid (3.4-svn) unstable; urgency=low maestro. - Merge context_start into context_new for sake of simplicity SURF: + * Add a Vivaldi network model, coded live during SUD'10 ;) * Rename configuration variables to start a hierarchy: o cpu_model -> cpu/model o network_model -> network/model diff --git a/buildtools/Cmake/src/CMakeDefinePackages.txt b/buildtools/Cmake/src/CMakeDefinePackages.txt index 720beb67ef..cc373074fa 100644 --- a/buildtools/Cmake/src/CMakeDefinePackages.txt +++ b/buildtools/Cmake/src/CMakeDefinePackages.txt @@ -196,6 +196,7 @@ set(SURF_SRC ${PROJECT_DIRECTORY}/src/surf/surfxml_parse.c ${PROJECT_DIRECTORY}/src/surf/cpu.c ${PROJECT_DIRECTORY}/src/surf/network.c + ${PROJECT_DIRECTORY}/src/surf/network_vivaldi.c ${PROJECT_DIRECTORY}/src/surf/network_constant.c ${PROJECT_DIRECTORY}/src/surf/workstation.c ${PROJECT_DIRECTORY}/src/surf/surf_model_timer.c diff --git a/src/include/surf/surf.h b/src/include/surf/surf.h index 08e83e1d09..633714c0b4 100644 --- a/src/include/surf/surf.h +++ b/src/include/surf/surf.h @@ -367,6 +367,8 @@ XBT_PUBLIC(void) surf_network_model_init_LegrandVelho(const char *filename); */ XBT_PUBLIC(void) surf_network_model_init_Constant(const char *filename); +XBT_PUBLIC(void) surf_network_model_init_Vivaldi(const char *filename); + /** \brief Initializes the platform with the network model CM02 * \ingroup SURF_models * \param filename XML platform file name diff --git a/src/surf/network_vivaldi.c b/src/surf/network_vivaldi.c new file mode 100644 index 0000000000..7b9b40bb10 --- /dev/null +++ b/src/surf/network_vivaldi.c @@ -0,0 +1,271 @@ +/* $Id$ */ + +/* Copyright (c) 2004 Arnaud Legrand. All rights reserved. */ + +/* 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 "surf_private.h" +#include "surf/random_mgr.h" +#include "xbt/dict.h" +#include "xbt/str.h" +#include "xbt/log.h" + +typedef struct surf_action_network_Vivaldi { + s_surf_action_t generic_action; + double latency; + double lat_init; + int suspended; +} s_surf_action_network_Vivaldi_t, *surf_action_network_Vivaldi_t; + +typedef struct s_netviva_coords { + double x,y,h; +} s_netviva_coords_t, *netviva_coords_t; +xbt_dict_t coords; /* Host name -> coordinates */ + +XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_network); +static random_data_t random_latency = NULL; +static int host_number_int = 0; + +static void netviva_count_hosts(void) +{ + host_number_int++; +} + +static void netviva_define_callbacks(const char *file) +{ + surfxml_add_callback(STag_surfxml_host_cb_list, &netviva_count_hosts); +} + +static int netviva_resource_used(void *resource_id) { + /* nothing to do here */ + return 0; +} + +static int netviva_action_unref(surf_action_t action) +{ + action->refcount--; + if (!action->refcount) { + xbt_swag_remove(action, action->state_set); + free(action); + return 1; + } + return 0; +} + +static void netviva_action_cancel(surf_action_t action) +{ + return; +} + +static void netviva_action_recycle(surf_action_t action) +{ + return; +} + +static double netviva_action_get_remains(surf_action_t action) +{ + return action->remains; +} + +/* look for the next event to finish */ +static double netviva_share_resources(double now) +{ + surf_action_network_Vivaldi_t action = NULL; + xbt_swag_t running_actions = surf_network_model->states.running_action_set; + double min = -1.0; + + xbt_swag_foreach(action, running_actions) { + if (action->latency > 0) { + if (min < 0) + min = action->latency; + else if (action->latency < min) + min = action->latency; + } + } + + return min; +} + +static void netviva_update_actions_state(double now, double delta) { + /* Advance the actions by delta seconds */ + surf_action_network_Vivaldi_t action = NULL; + surf_action_network_Vivaldi_t next_action = NULL; + xbt_swag_t running_actions = surf_network_model->states.running_action_set; + + xbt_swag_foreach_safe(action, next_action, running_actions) { + if (action->latency > 0) { + if (action->latency > delta) { + double_update(&(action->latency), delta); + } else { + action->latency = 0.0; + } + } + double_update(&(action->generic_action.remains), + action->generic_action.cost * delta / action->lat_init); + if (action->generic_action.max_duration != NO_MAX_DURATION) + double_update(&(action->generic_action.max_duration), delta); + + if (action->generic_action.remains <= 0) { /* This action is done, inform SURF about it */ + action->generic_action.finish = surf_get_clock(); + surf_network_model->action_state_set((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_network_model->action_state_set((surf_action_t) action, + SURF_ACTION_DONE); + } + } +} + +static void netviva_update_resource_state(void *id, + tmgr_trace_event_t event_type, + double value, double time) +{ /* Called as soon as there is a trace modification */ + DIE_IMPOSSIBLE; +} + +static surf_action_t netviva_communicate(const char *src_name, const char *dst_name, + int src, int dst, double size, double rate) +{ + netviva_coords_t c1,c2; + c1 = xbt_dict_get(coords,src_name); + c2 = xbt_dict_get(coords,dst_name); + + surf_action_network_Vivaldi_t action = NULL; + + action = + surf_action_new(sizeof(s_surf_action_network_Vivaldi_t), size, + surf_network_model, 0); + + action->suspended = 0; + + action->latency = sqrt((c1->x-c2->x)*(c1->x-c2->x) + (c1->y-c2->y)*(c1->y-c2->y)) + fabs(c1->h)+ fabs(c2->h) ; //random_generate(random_latency); + action->lat_init = action->latency; + + if (action->latency <= 0.0) { + action->generic_action.state_set = + surf_network_model->states.done_action_set; + xbt_swag_insert(action, action->generic_action.state_set); + } + + return (surf_action_t) action; +} + +/* returns an array of link_Vivaldi_t */ +static xbt_dynar_t netviva_get_route(void *src, void *dst) +{ + xbt_die("Calling this function does not make any sense"); +} + +static double netviva_get_link_bandwidth(const void *link) +{ + DIE_IMPOSSIBLE; +} + +static double netviva_get_link_latency(const void *link) +{ + DIE_IMPOSSIBLE; +} + +static int link_shared(const void *link) +{ + DIE_IMPOSSIBLE; +} + +static void netviva_action_suspend(surf_action_t action) +{ + ((surf_action_network_Vivaldi_t) action)->suspended = 1; +} + +static void netviva_action_resume(surf_action_t action) +{ + if (((surf_action_network_Vivaldi_t) action)->suspended) + ((surf_action_network_Vivaldi_t) action)->suspended = 0; +} + +static int netviva_action_is_suspended(surf_action_t action) +{ + return ((surf_action_network_Vivaldi_t) action)->suspended; +} + +static void netviva_action_set_max_duration(surf_action_t action, double duration) +{ + action->max_duration = duration; +} + +static void netviva_finalize(void) +{ + surf_model_exit(surf_network_model); + surf_network_model = NULL; +} + + +static void net_define_callbacks(const char *file) +{ + /* Figuring out the network links */ +} + +static void netviva_parse_host(void) { + netviva_coords_t coord = xbt_new(s_netviva_coords_t,1); + + xbt_dynar_t ctn =xbt_str_split_str(A_surfxml_host_vivaldi," "); + + coord->x = atof(xbt_dynar_get_as(ctn, 0, char*)); + coord->y = atof(xbt_dynar_get_as(ctn, 1, char*)); + coord->h = atof(xbt_dynar_get_as(ctn, 2, char*)); + + xbt_dynar_free(&ctn); + xbt_dict_set(coords, A_surfxml_host_id,coord,NULL); +} + +void surf_network_model_init_Vivaldi(const char *filename) +{ + xbt_assert(surf_network_model == NULL); + if (surf_network_model) + return; + surf_network_model = surf_model_init(); + coords = xbt_dict_new(); + + INFO0("Blih"); + surf_network_model->name = "Vivaldi time network"; + surf_network_model->action_unref = netviva_action_unref; + surf_network_model->action_cancel = netviva_action_cancel; + surf_network_model->action_recycle = netviva_action_recycle; + surf_network_model->get_remains = netviva_action_get_remains; + + surf_network_model->model_private->resource_used = netviva_resource_used; + surf_network_model->model_private->share_resources = netviva_share_resources; + surf_network_model->model_private->update_actions_state = + netviva_update_actions_state; + surf_network_model->model_private->update_resource_state = + netviva_update_resource_state; + surf_network_model->model_private->finalize = netviva_finalize; + + surf_network_model->suspend = netviva_action_suspend; + surf_network_model->resume = netviva_action_resume; + surf_network_model->is_suspended = netviva_action_is_suspended; + surf_cpu_model->set_max_duration = netviva_action_set_max_duration; + + surf_network_model->extension.network.communicate = netviva_communicate; + surf_network_model->extension.network.get_link_bandwidth = + netviva_get_link_bandwidth; + surf_network_model->extension.network.get_link_latency = netviva_get_link_latency; + surf_network_model->extension.network.link_shared = link_shared; + + if (!random_latency) + random_latency = random_new(RAND, 100, 0.0, 1.0, .125, .034); + netviva_define_callbacks(filename); + xbt_dynar_push(model_list, &surf_network_model); + + /* Callbacks settings */ + surfxml_add_callback(STag_surfxml_host_cb_list, &netviva_parse_host); + + update_model_description(surf_network_model_description, + "Vivaldi", surf_network_model); + + xbt_cfg_set_string(_surf_cfg_set, "routing", "none"); + routing_model_create(sizeof(double), NULL); +} + diff --git a/src/surf/simgrid.dtd b/src/surf/simgrid.dtd index dfd9943eee..5e09120b2a 100644 --- a/src/surf/simgrid.dtd +++ b/src/surf/simgrid.dtd @@ -45,6 +45,7 @@ + diff --git a/src/surf/surf.c b/src/surf/surf.c index dec52bf82e..a211395bf9 100644 --- a/src/surf/surf.c +++ b/src/surf/surf.c @@ -112,7 +112,8 @@ xbt_dynar_t surf_path = NULL; /* Don't forget to update the option description in smx_config when you change this */ s_surf_model_description_t surf_network_model_description[] = { - {"Constant", "Simplistic network model where all communication take a constant time (one second)", NULL, surf_network_model_init_Constant}, + {"Constant", "Simplistic network model where all communication take a constant time (one second)", NULL, surf_network_model_init_Constant}, + {"Vivaldi", "Scalable network model using the Vivaldi coordinate ideas", NULL, surf_network_model_init_Vivaldi}, {"CM02", "Realistic network model with lmm_solve and no correction factors", NULL, surf_network_model_init_CM02}, {"LV08", "Realistic network model with lmm_solve and these correction factors: latency*=10.4, bandwidth*=.92, S=8775" , NULL, surf_network_model_init_LegrandVelho}, #ifdef HAVE_GTNETS