void surf_config_models_setup(const char *platform_file) { char *workstation_model_name; int workstation_id = -1; char *network_model_name = NULL; char *cpu_model_name = NULL; workstation_model_name = xbt_cfg_get_string(_surf_cfg_set, "workstation/model"); network_model_name = xbt_cfg_get_string(_surf_cfg_set, "network/model"); cpu_model_name = xbt_cfg_get_string(_surf_cfg_set, "cpu/model"); /* Check whether we use a net/cpu model differing from the default ones, in which case * we should switch to the "compound" workstation model to correctly dispatch stuff to * the right net/cpu models. */ if ((strcmp(network_model_name, "LV08") || strcmp(cpu_model_name, "Cas01")) && !strcmp(workstation_model_name, "CLM03")) { const char *val = "compound"; XBT_INFO ("Switching workstation model to compound since you changed the network and/or cpu model(s)"); xbt_cfg_set_string(_surf_cfg_set, "workstation/model", val); workstation_model_name = (char *) "compound"; } XBT_DEBUG("Workstation model: %s", workstation_model_name); workstation_id = find_model_description(surf_workstation_model_description, workstation_model_name); if (!strcmp(workstation_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' workstation model"); xbt_assert(network_model_name, "Set a network model to use with the 'compound' workstation model"); network_id = find_model_description(surf_network_model_description, network_model_name); cpu_id = find_model_description(surf_cpu_model_description, cpu_model_name); surf_cpu_model_description[cpu_id].model_init_preparse(platform_file); surf_network_model_description[network_id].model_init_preparse (platform_file); } XBT_DEBUG("Call workstation_model_init"); surf_workstation_model_description[workstation_id].model_init_preparse (platform_file); }
CpuCas01Model::CpuCas01Model() : simgrid::surf::CpuModel() { char *optim = xbt_cfg_get_string("cpu/optim"); bool select = xbt_cfg_get_boolean("cpu/maxmin-selective-update"); if (!strcmp(optim, "Full")) { updateMechanism_ = UM_FULL; selectiveUpdate_ = select; } else if (!strcmp(optim, "Lazy")) { updateMechanism_ = UM_LAZY; selectiveUpdate_ = true; xbt_assert(select || (xbt_cfg_is_default_value("cpu/maxmin-selective-update")), "Disabling selective update while using the lazy update mechanism is dumb!"); } else { xbt_die("Unsupported optimization (%s) for this model", optim); } p_cpuRunningActionSetThatDoesNotNeedBeingChecked = new ActionList(); maxminSystem_ = lmm_system_new(selectiveUpdate_); if (getUpdateMechanism() == UM_LAZY) { actionHeap_ = xbt_heap_new(8, nullptr); xbt_heap_set_update_callback(actionHeap_, surf_action_lmm_update_index_heap); modifiedSet_ = new ActionLmmList(); maxminSystem_->keep_track = modifiedSet_; } }
void _mc_cfg_cb_dot_output(const char *name) { if (_sg_cfg_init_status && !_sg_do_model_check) xbt_die ("You are specifying a file name for a dot output of graph state after the initialization (through MSG_config?), but model-checking was not activated at config time (through bu the program was not runned under the model-checker (with simgrid-mc)). This won't work, sorry."); _sg_mc_dot_output_file = xbt_cfg_get_string(name); }
/* callback of the cpu/model variable */ static void _sg_cfg_cb__storage_mode(const char *name) { xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization"); char *val = xbt_cfg_get_string(name); if (!strcmp(val, "help")) { model_help("storage", surf_storage_model_description); sg_cfg_exit_early(); } find_model_description(surf_storage_model_description, val); }
void surf_config_models_create_elms(void) { char *workstation_model_name = xbt_cfg_get_string(_surf_cfg_set, "workstation/model"); int workstation_id = find_model_description(surf_workstation_model_description, workstation_model_name); if (surf_workstation_model_description [workstation_id].model_init_postparse != NULL) surf_workstation_model_description[workstation_id].model_init_postparse (); }
/* callback of the network_model variable */ static void _sg_cfg_cb__network_model(const char *name) { xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization"); char *val = xbt_cfg_get_string(name); if (!strcmp(val, "help")) { model_help("network", surf_network_model_description); sg_cfg_exit_early(); } /* New Module missing */ find_model_description(surf_network_model_description, val); }
/* callback of the vm/model variable */ static void _sg_cfg_cb__vm_model(const char *name) { xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization"); char *val = xbt_cfg_get_string(name); if (!strcmp(val, "help")) { model_help("vm", surf_vm_model_description); sg_cfg_exit_early(); } /* Make sure that the model exists */ find_model_description(surf_vm_model_description, val); }
/* callback of the mpi collectives: simply check that this is a valid name. It will be picked up in smpi_global.cpp */ static void _check_coll(const char *category, s_mpi_coll_description_t * table, const char *name) { xbt_assert(_sg_cfg_init_status < 2, "Cannot change the collective algorithm after the initialization"); char *val = xbt_cfg_get_string(name); if (val && !strcmp(val, "help")) { coll_help(category, table); sg_cfg_exit_early(); } find_coll_description(table, val, category); }
int TRACE_start() { if (TRACE_is_configured()) TRACE_getopts(); // tracing system must be: // - enabled (with --cfg=tracing:yes) // - already configured (TRACE_global_init already called) if (TRACE_is_enabled()) { XBT_DEBUG("Tracing starts"); /* init the tracing module to generate the right output */ /* open internal buffer */ TRACE_init(); /* open the trace file(s) */ const char* format = xbt_cfg_get_string(OPT_TRACING_FORMAT); XBT_DEBUG("Tracing format %s\n", format); if(!strcmp(format, "Paje")){ TRACE_paje_init(); TRACE_paje_start(); }else if (!strcmp(format, "TI")){ TRACE_TI_init(); TRACE_TI_start(); }else{ xbt_die("Unknown trace format :%s ", format); } /* activate trace */ if (trace_active == 1) { THROWF(tracing_error, 0, "Tracing is already active"); } trace_active = 1; XBT_DEBUG("Tracing is on"); /* other trace initialization */ created_categories = xbt_dict_new_homogeneous(xbt_free_f); declared_marks = xbt_dict_new_homogeneous(xbt_free_f); user_host_variables = xbt_dict_new_homogeneous(xbt_free_f); user_vm_variables = xbt_dict_new_homogeneous(xbt_free_f); user_link_variables = xbt_dict_new_homogeneous(xbt_free_f); if (TRACE_start_functions != NULL) { void (*func) (); unsigned int iter; xbt_dynar_foreach(TRACE_start_functions, iter, func) { func(); } } }
void _mc_cfg_cb_reduce(const char *name) { if (_sg_cfg_init_status && !_sg_do_model_check) xbt_die ("You are specifying a reduction strategy after the initialization (through MSG_config?), but model-checking was not activated at config time (through bu the program was not runned under the model-checker (with simgrid-mc)). This won't work, sorry."); char *val = xbt_cfg_get_string(name); if (!strcasecmp(val, "none")) simgrid::mc::reduction_mode = simgrid::mc::ReductionMode::none; else if (!strcasecmp(val, "dpor")) simgrid::mc::reduction_mode = simgrid::mc::ReductionMode::dpor; else xbt_die("configuration option %s can only take 'none' or 'dpor' as a value", name); }
/* callback of the plugin variable */ static void _sg_cfg_cb__plugin(const char *name) { xbt_assert(_sg_cfg_init_status < 2, "Cannot load a plugin after the initialization"); char *val = xbt_cfg_get_string(name); if (val==nullptr || val[0] == '\0') return; if (!strcmp(val, "help")) { model_help("plugin", surf_plugin_description); sg_cfg_exit_early(); } int plugin_id = find_model_description(surf_plugin_description, val); surf_plugin_description[plugin_id].model_init_preparse(); }
static void _surf_cfg_cb__surf_network_coordinates(const char *name, int pos) { char *val = xbt_cfg_get_string(_surf_cfg_set, name); if (!strcmp(val, "yes")) { if (!COORD_HOST_LEVEL) { COORD_HOST_LEVEL = xbt_lib_add_level(host_lib,xbt_dynar_free_voidp); COORD_ASR_LEVEL = xbt_lib_add_level(as_router_lib,xbt_dynar_free_voidp); } } else if (!strcmp(val, "no")) { if (COORD_HOST_LEVEL) xbt_die("Setting of whether to use coordinate cannot be disabled once set."); } else { xbt_die("Command line setting of whether to use coordinates must be either \"yes\" or \"no\""); } }
double NetworkSmpiModel::latencyFactor(double size) { if (smpi_lat_factor.empty()) smpi_lat_factor = parse_factor(xbt_cfg_get_string("smpi/lat-factor")); double current=1.0; for (auto fact: smpi_lat_factor) { if (size <= fact.factor) { XBT_DEBUG("%f <= %zu return %f", size, fact.factor, current); return current; } else current=fact.values.front(); } XBT_DEBUG("%f > %zu return %f", size, smpi_lat_factor.back().factor, current); return current; }
/* callback of the workstation/model variable */ static void _sg_cfg_cb__workstation_model(const char *name, int pos) { char *val; xbt_assert(_sg_init_status == 1, "Cannot change the model after the initialization"); val = xbt_cfg_get_string(_sg_cfg_set, name); if (!strcmp(val, "help")) { model_help("workstation", surf_workstation_model_description); exit(0); } /* Make sure that the model exists */ find_model_description(surf_workstation_model_description, val); }
/* callback of the workstation_model variable */ static void _sg_cfg_cb__network_model(const char *name, int pos) { char *val; xbt_assert(_sg_init_status == 1, "Cannot change the model after the initialization"); val = xbt_cfg_get_string(_sg_cfg_set, name); if (!strcmp(val, "help")) { model_help("network", surf_network_model_description); exit(0); } /* New Module missing */ find_model_description(surf_network_model_description, val); }
/* callback of the cpu/model variable */ static void _sg_cfg_cb__storage_mode(const char *name, int pos) { char *val; xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization"); val = xbt_cfg_get_string(_sg_cfg_set, name); if (!strcmp(val, "help")) { model_help("storage", surf_storage_model_description); sg_cfg_exit_early(); } /* New Module missing */ find_model_description(surf_storage_model_description, val); }
static void _sg_cfg_cb_contexts_parallel_mode(const char *name, int pos) { const char* mode_name = xbt_cfg_get_string(_sg_cfg_set, name); if (!strcmp(mode_name, "posix")) { SIMIX_context_set_parallel_mode(XBT_PARMAP_POSIX); } else if (!strcmp(mode_name, "futex")) { SIMIX_context_set_parallel_mode(XBT_PARMAP_FUTEX); } else if (!strcmp(mode_name, "busy_wait")) { SIMIX_context_set_parallel_mode(XBT_PARMAP_BUSY_WAIT); } else { xbt_die("Command line setting of the parallel synchronization mode should " "be one of \"posix\", \"futex\" or \"busy_wait\""); } }
/********* * Model * *********/ void surf_cpu_model_init_Cas01() { xbt_assert(!surf_cpu_model_pm); xbt_assert(!surf_cpu_model_vm); char *optim = xbt_cfg_get_string("cpu/optim"); if (!strcmp(optim, "TI")) { surf_cpu_model_init_ti(); return; } surf_cpu_model_pm = new simgrid::surf::CpuCas01Model(); all_existing_models->push_back(surf_cpu_model_pm); surf_cpu_model_vm = new simgrid::surf::CpuCas01Model(); all_existing_models->push_back(surf_cpu_model_vm); }
/* callback of the mpi collectives */ static void _sg_cfg_cb__coll(const char *category, s_mpi_coll_description_t * table, const char *name, int pos) { char *val; xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization"); val = xbt_cfg_get_string(_sg_cfg_set, name); if (!strcmp(val, "help")) { coll_help(category, table); sg_cfg_exit_early(); } /* New Module missing */ find_coll_description(table, val, category); }
CpuCas01Model::CpuCas01Model() : CpuModel("cpu") { char *optim = xbt_cfg_get_string(_sg_cfg_set, "cpu/optim"); int select = xbt_cfg_get_boolean(_sg_cfg_set, "cpu/maxmin_selective_update"); if (!strcmp(optim, "Full")) { p_updateMechanism = UM_FULL; m_selectiveUpdate = select; } else if (!strcmp(optim, "Lazy")) { p_updateMechanism = UM_LAZY; m_selectiveUpdate = 1; xbt_assert((select == 1) || (xbt_cfg_is_default_value (_sg_cfg_set, "cpu/maxmin_selective_update")), "Disabling selective update while using the lazy update mechanism is dumb!"); } else { xbt_die("Unsupported optimization (%s) for this model", optim); } p_cpuRunningActionSetThatDoesNotNeedBeingChecked = new ActionList(); if (getUpdateMechanism() == UM_LAZY) { shareResources = &CpuCas01Model::shareResourcesLazy; updateActionsState = &CpuCas01Model::updateActionsStateLazy; } else if (getUpdateMechanism() == UM_FULL) { shareResources = &CpuCas01Model::shareResourcesFull; updateActionsState = &CpuCas01Model::updateActionsStateFull; } else xbt_die("Invalid cpu update mechanism!"); if (!p_maxminSystem) { p_maxminSystem = lmm_system_new(m_selectiveUpdate); } if (getUpdateMechanism() == UM_LAZY) { p_actionHeap = xbt_heap_new(8, NULL); xbt_heap_set_update_callback(p_actionHeap, surf_action_lmm_update_index_heap); p_modifiedSet = new ActionLmmList(); p_maxminSystem->keep_track = p_modifiedSet; } }
/* callback of the plugin variable */ static void _sg_cfg_cb__plugin(const char *name, int pos) { char *val; XBT_VERB("PLUGIN"); xbt_assert(_sg_cfg_init_status < 2, "Cannot load a plugin after the initialization"); val = xbt_cfg_get_string(_sg_cfg_set, name); if (!strcmp(val, "help")) { model_help("plugin", surf_plugin_description); sg_cfg_exit_early(); } /* New Module missing */ int plugin_id = find_model_description(surf_plugin_description, val); surf_plugin_description[plugin_id].model_init_preparse(); }
/********* * Model * *********/ void surf_cpu_model_init_Cas01() { char *optim = xbt_cfg_get_string(_sg_cfg_set, "cpu/optim"); xbt_assert(!surf_cpu_model_pm); xbt_assert(!surf_cpu_model_vm); if (!strcmp(optim, "TI")) { surf_cpu_model_init_ti(); return; } surf_cpu_model_pm = new CpuCas01Model(); surf_cpu_model_vm = new CpuCas01Model(); cpu_define_callbacks(); ModelPtr model_pm = surf_cpu_model_pm; ModelPtr model_vm = surf_cpu_model_vm; xbt_dynar_push(model_list, &model_pm); xbt_dynar_push(model_list, &model_vm); }
void NetworkCm02Model::initialize() { char *optim = xbt_cfg_get_string(_sg_cfg_set, "network/optim"); int select = xbt_cfg_get_boolean(_sg_cfg_set, "network/maxmin_selective_update"); if (!strcmp(optim, "Full")) { p_updateMechanism = UM_FULL; m_selectiveUpdate = select; } else if (!strcmp(optim, "Lazy")) { p_updateMechanism = UM_LAZY; m_selectiveUpdate = 1; xbt_assert((select == 1) || (xbt_cfg_is_default_value (_sg_cfg_set, "network/maxmin_selective_update")), "Disabling selective update while using the lazy update mechanism is dumb!"); } else { xbt_die("Unsupported optimization (%s) for this model", optim); } if (!p_maxminSystem) p_maxminSystem = lmm_system_new(m_selectiveUpdate); const char* lb_name = "__loopback__"; routing_model_create(createNetworkLink(lb_name, 498000000, NULL, 0.000015, NULL, SURF_RESOURCE_ON, NULL, SURF_LINK_FATPIPE, NULL)); if (p_updateMechanism == UM_LAZY) { p_actionHeap = xbt_heap_new(8, NULL); xbt_heap_set_update_callback(p_actionHeap, surf_action_lmm_update_index_heap); p_modifiedSet = new ActionLmmList(); p_maxminSystem->keep_track = p_modifiedSet; } m_haveGap = false; }
char *TRACE_get_viva_cat_conf (void) { return xbt_cfg_get_string(_surf_cfg_set, OPT_VIVA_CAT_CONF); }
char *TRACE_get_filename(void) { return xbt_cfg_get_string(_surf_cfg_set, OPT_TRACING_FILENAME); }
char *TRACE_get_comment_file (void) { return xbt_cfg_get_string(_surf_cfg_set, OPT_TRACING_COMMENT_FILE); }
static void _sg_cfg_cb_context_factory(const char *name, int pos) { smx_context_factory_name = xbt_cfg_get_string(_sg_cfg_set, name); }
static void _sg_cfg_cb_model_check_replay(const char *name, int pos) { MC_record_path = xbt_cfg_get_string(_sg_cfg_set, name); }
char* sg_cfg_get_string(const char* name) { return xbt_cfg_get_string(_sg_cfg_set, name); }
/* Pick the right models for CPU, net and host, and call their model_init_preparse */ 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); } 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(); }