X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/a58e259d1637e654feb295098ad879cd7bab8bf2..55633c554b60455d85885816b1b73e9698b73a14:/src/surf/sg_platf.cpp diff --git a/src/surf/sg_platf.cpp b/src/surf/sg_platf.cpp index 26a982e936..e3f704fe40 100644 --- a/src/surf/sg_platf.cpp +++ b/src/surf/sg_platf.cpp @@ -10,17 +10,15 @@ #include "xbt/dict.h" #include "xbt/RngStream.h" #include -#include "simgrid/platf_interface.h" +#include "src/surf/HostImpl.hpp" #include "surf/surf.h" #include "src/simix/smx_private.h" -#include "src/surf/platform.hpp" -#include "surf/surfxml_parse.h"// FIXME: brain dead public header +#include "src/include/simgrid/sg_config.h" +#include "src/surf/xml/platf_private.hpp" -#include "src/surf/platform.hpp" #include "src/surf/cpu_interface.hpp" -#include "src/surf/host_interface.hpp" #include "src/surf/network_interface.hpp" #include "surf/surf_routing.h" // FIXME: brain dead public header #include "src/surf/surf_routing_cluster.hpp" @@ -43,9 +41,6 @@ simgrid::xbt::signal on_postparse; static int surf_parse_models_setup_already_called = 0; -/* one RngStream for the platform, to respect some statistic rules */ -static RngStream sg_platf_rng_stream = NULL; - /** Module management function: creates all internal data structures */ void sg_platf_init(void) { } @@ -58,6 +53,7 @@ void sg_platf_exit(void) { /* make sure that we will reinit the models while loading the platf once reinited */ surf_parse_models_setup_already_called = 0; + surf_parse_lex_destroy(); } /** @brief Add an "host" to the current AS */ @@ -105,11 +101,14 @@ void sg_platf_new_host(sg_platf_host_cbarg_t host) simgrid::surf::Cpu *cpu = surf_cpu_model_pm->createCpu( h, host->speed_peak, - host->pstate, - host->speed_scale, host->speed_trace, + host->speed_trace, host->core_amount, - host->initiallyOn, host->state_trace); + host->state_trace); surf_host_model->createHost(host->id, netcard, cpu, host->properties)->attach(h); + + if (host->pstate != 0) + cpu->setPState(host->pstate); + simgrid::s4u::Host::onCreation(*h); if (TRACE_is_enabled() && TRACE_needs_platform()) @@ -125,15 +124,14 @@ void sg_platf_new_router(sg_platf_router_cbarg_t router) if (current_routing->hierarchy_ == SURF_ROUTING_NULL) current_routing->hierarchy_ = SURF_ROUTING_BASE; - xbt_assert(!xbt_lib_get_or_null(as_router_lib, router->id, ROUTING_ASR_LEVEL), - "Reading a router, processing unit \"%s\" already exists", - router->id); + xbt_assert(nullptr == xbt_lib_get_or_null(as_router_lib, router->id, ROUTING_ASR_LEVEL), + "Refusing to create a router named '%s': this name already describes a node.", router->id); - simgrid::surf::NetCard *info = new simgrid::surf::NetCardImpl(router->id, SURF_NETWORK_ELEMENT_ROUTER, current_routing); - info->setId(current_routing->addComponent(info)); - xbt_lib_set(as_router_lib, router->id, ROUTING_ASR_LEVEL, (void *) info); - XBT_DEBUG("Having set name '%s' id '%d'", router->id, info->id()); - simgrid::surf::netcardCreatedCallbacks(info); + simgrid::surf::NetCard *netcard = new simgrid::surf::NetCardImpl(router->id, SURF_NETWORK_ELEMENT_ROUTER, current_routing); + netcard->setId(current_routing->addComponent(netcard)); + xbt_lib_set(as_router_lib, router->id, ROUTING_ASR_LEVEL, (void *) netcard); + XBT_DEBUG("Having set name '%s' id '%d'", router->id, netcard->id()); + simgrid::surf::netcardCreatedCallbacks(netcard); if (router->coord && strcmp(router->coord, "")) { unsigned int cursor; @@ -208,13 +206,13 @@ void sg_platf_new_cluster(sg_platf_cluster_cbarg_t cluster) static_cast(current_routing)->parse_specific_arguments(cluster); if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){ - ((AsCluster*)current_routing)->p_nb_links_per_node++; - ((AsCluster*)current_routing)->p_has_loopback=1; + ((AsCluster*)current_routing)->nb_links_per_node_++; + ((AsCluster*)current_routing)->has_loopback_=1; } if(cluster->limiter_link!=0){ - ((AsCluster*)current_routing)->p_nb_links_per_node++; - ((AsCluster*)current_routing)->p_has_limiter=1; + ((AsCluster*)current_routing)->nb_links_per_node_++; + ((AsCluster*)current_routing)->has_limiter_=1; } @@ -278,9 +276,7 @@ void sg_platf_new_cluster(sg_platf_cluster_cbarg_t cluster) host.pstate = 0; //host.power_peak = cluster->power; - host.speed_scale = 1.0; host.core_amount = cluster->core_amount; - host.initiallyOn = 1; host.coord = ""; sg_platf_new_host(&host); xbt_dynar_free(&host.speed_peak); @@ -309,14 +305,13 @@ void sg_platf_new_cluster(sg_platf_cluster_cbarg_t cluster) link.id = tmp_link; link.bandwidth = cluster->loopback_bw; link.latency = cluster->loopback_lat; - link.initiallyOn = 1; link.policy = SURF_LINK_FATPIPE; sg_platf_new_link(&link); info_loop.link_up = Link::byName(tmp_link); info_loop.link_down = info_loop.link_up; free(tmp_link); xbt_dynar_set(current_routing->upDownLinks, - rankId*(static_cast(current_routing))->p_nb_links_per_node, &info_loop); + rankId*(static_cast(current_routing))->nb_links_per_node_, &info_loop); } //add a limiter link (shared link to account for maximal bandwidth of the node) @@ -330,7 +325,6 @@ void sg_platf_new_cluster(sg_platf_cluster_cbarg_t cluster) link.id = tmp_link; link.bandwidth = cluster->limiter_link; link.latency = 0; - link.initiallyOn = 1; link.policy = SURF_LINK_SHARED; sg_platf_new_link(&link); info_lim.link_up = Link::byName(tmp_link); @@ -338,7 +332,7 @@ void sg_platf_new_cluster(sg_platf_cluster_cbarg_t cluster) free(tmp_link); auto as_cluster = static_cast(current_routing); xbt_dynar_set(current_routing->upDownLinks, - rankId*(as_cluster)->p_nb_links_per_node + as_cluster->p_has_loopback , + rankId*(as_cluster)->nb_links_per_node_ + as_cluster->has_loopback_ , &info_lim); } @@ -350,9 +344,9 @@ void sg_platf_new_cluster(sg_platf_cluster_cbarg_t cluster) } else { static_cast(current_routing)->create_links_for_node(cluster, i, rankId, rankId* - static_cast(current_routing)->p_nb_links_per_node - + static_cast(current_routing)->p_has_loopback - + static_cast(current_routing)->p_has_limiter ); + static_cast(current_routing)->nb_links_per_node_ + + static_cast(current_routing)->has_loopback_ + + static_cast(current_routing)->has_limiter_ ); } xbt_free(link_id); xbt_free(host_id); @@ -381,7 +375,7 @@ void sg_platf_new_cluster(sg_platf_cluster_cbarg_t cluster) bprintf("%s%s_router%s", cluster->prefix, cluster->id, cluster->suffix); sg_platf_new_router(&router); - ((AsCluster*)current_routing)->p_router = (simgrid::surf::NetCard*) xbt_lib_get_or_null(as_router_lib, router.id, ROUTING_ASR_LEVEL); + ((AsCluster*)current_routing)->router_ = (simgrid::surf::NetCard*) xbt_lib_get_or_null(as_router_lib, router.id, ROUTING_ASR_LEVEL); free(newid); //Make the backbone @@ -394,7 +388,6 @@ void sg_platf_new_cluster(sg_platf_cluster_cbarg_t cluster) link.id = link_backbone; link.bandwidth = cluster->bb_bw; link.latency = cluster->bb_lat; - link.initiallyOn = 1; link.policy = cluster->bb_sharing_policy; sg_platf_new_link(&link); @@ -513,18 +506,17 @@ void sg_platf_new_mount(sg_platf_mount_cbarg_t mount){ void sg_platf_new_route(sg_platf_route_cbarg_t route) { - routing_get_current()->parseRoute(route); + routing_get_current()->addRoute(route); } void sg_platf_new_bypassRoute(sg_platf_route_cbarg_t bypassRoute) { - routing_get_current()->parseBypassroute(bypassRoute); + routing_get_current()->addBypassRoute(bypassRoute); } void sg_platf_new_process(sg_platf_process_cbarg_t process) { - if (!simix_global) - xbt_die("Cannot create process without SIMIX."); + xbt_assert(simix_global,"Cannot create process without SIMIX."); sg_host_t host = sg_host_by_name(process->host); if (!host) { @@ -617,27 +609,79 @@ void sg_platf_new_process(sg_platf_process_cbarg_t process) current_property_set = NULL; } -void sg_platf_route_begin (sg_platf_route_cbarg_t route){ - route->link_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref); -} +void sg_platf_begin() { /* Do nothing: just for symmetry of user code */ } -void sg_platf_route_end (sg_platf_route_cbarg_t route){ - sg_platf_new_route(route); +void sg_platf_end() { + simgrid::surf::on_postparse(); } -void sg_platf_route_add_link (const char* link_id, sg_platf_route_cbarg_t route){ - char *link_name = xbt_strdup(link_id); - xbt_dynar_push(route->link_list, &link_name); -} -void sg_platf_ASroute_add_link (const char* link_id, sg_platf_route_cbarg_t ASroute){ - char *link_name = xbt_strdup(link_id); - xbt_dynar_push(ASroute->link_list, &link_name); -} +/* Pick the right models for CPU, net and host, and call their model_init_preparse */ +static void surf_config_models_setup() +{ + const char *host_model_name; + const char *vm_model_name; + int host_id = -1; + int vm_id = -1; + char *network_model_name = NULL; + char *cpu_model_name = NULL; + int storage_id = -1; + char *storage_model_name = NULL; + + host_model_name = xbt_cfg_get_string(_sg_cfg_set, "host/model"); + vm_model_name = xbt_cfg_get_string(_sg_cfg_set, "vm/model"); + network_model_name = xbt_cfg_get_string(_sg_cfg_set, "network/model"); + cpu_model_name = xbt_cfg_get_string(_sg_cfg_set, "cpu/model"); + storage_model_name = xbt_cfg_get_string(_sg_cfg_set, "storage/model"); + + /* Check whether we use a net/cpu model differing from the default ones, in which case + * we should switch to the "compound" host model to correctly dispatch stuff to + * the right net/cpu models. + */ + + if ((!xbt_cfg_is_default_value(_sg_cfg_set, "network/model") || + !xbt_cfg_is_default_value(_sg_cfg_set, "cpu/model")) && + xbt_cfg_is_default_value(_sg_cfg_set, "host/model")) { + host_model_name = "compound"; + xbt_cfg_set_string(_sg_cfg_set, "host/model", host_model_name); + } -void sg_platf_begin() { /* Do nothing: just for symmetry of user code */ } + XBT_DEBUG("host model: %s", host_model_name); + host_id = find_model_description(surf_host_model_description, host_model_name); + if (!strcmp(host_model_name, "compound")) { + int network_id = -1; + int cpu_id = -1; + + xbt_assert(cpu_model_name, + "Set a cpu model to use with the 'compound' host model"); + + xbt_assert(network_model_name, + "Set a network model to use with the 'compound' host model"); + + if(surf_cpu_model_init_preparse){ + surf_cpu_model_init_preparse(); + } else { + cpu_id = + find_model_description(surf_cpu_model_description, cpu_model_name); + surf_cpu_model_description[cpu_id].model_init_preparse(); + } + + network_id = + find_model_description(surf_network_model_description, + network_model_name); + surf_network_model_description[network_id].model_init_preparse(); + } + + XBT_DEBUG("Call host_model_init"); + surf_host_model_description[host_id].model_init_preparse(); + + XBT_DEBUG("Call vm_model_init"); + vm_id = find_model_description(surf_vm_model_description, vm_model_name); + surf_vm_model_description[vm_id].model_init_preparse(); + + XBT_DEBUG("Call storage_model_init"); + storage_id = find_model_description(surf_storage_model_description, storage_model_name); + surf_storage_model_description[storage_id].model_init_preparse(); -void sg_platf_end() { - simgrid::surf::on_postparse(); } void sg_platf_new_AS_begin(sg_platf_AS_cbarg_t AS) @@ -675,20 +719,3 @@ void sg_platf_new_AS_end() if (TRACE_is_enabled()) sg_instr_AS_end(); } -/* ***************************************** */ - -void sg_platf_rng_stream_init(unsigned long seed[6]) { - RngStream_SetPackageSeed(seed); - sg_platf_rng_stream = RngStream_CreateStream(NULL); -} - -RngStream sg_platf_rng_stream_get(const char* id) { - RngStream stream = NULL; - unsigned int id_hash; - - stream = RngStream_CopyStream(sg_platf_rng_stream); - id_hash = xbt_str_hash(id); - RngStream_AdvanceState(stream, 0, (long)id_hash); - - return stream; -}