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_; } }
static void smpi_check_options(){ //check correctness of MPI parameters xbt_assert(xbt_cfg_get_int("smpi/async-small-thresh") <= xbt_cfg_get_int("smpi/send-is-detached-thresh")); if (xbt_cfg_is_default_value("smpi/running-power")) { XBT_INFO("You did not set the power of the host running the simulation. " "The timings will certainly not be accurate. " "Use the option \"--cfg=smpi/running-power:<flops>\" to set its value." "Check http://simgrid.org/simgrid/latest/doc/options.html#options_smpi_bench for more information."); } }
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; } }
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; }
int sg_cfg_is_default_value(const char *name) { return xbt_cfg_is_default_value(_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(); }
/* Pick the right models for CPU, net and workstation, and call their model_init_preparse */ void surf_config_models_setup() { char *workstation_model_name; int workstation_id = -1; char *network_model_name = NULL; char *cpu_model_name = NULL; int storage_id = -1; char *storage_model_name = NULL; workstation_model_name = xbt_cfg_get_string(_sg_cfg_set, "workstation/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" workstation 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, "workstation/model")) { 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(_sg_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(); surf_network_model_description[network_id].model_init_preparse(); } XBT_DEBUG("Call workstation_model_init"); surf_workstation_model_description[workstation_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(); /* ********************************************************************* */ /* TUTORIAL: New model */ int new_model_id = -1; char *new_model_name = NULL; new_model_name = xbt_cfg_get_string(_sg_cfg_set, "new_model/model"); XBT_DEBUG("Call new model_init"); new_model_id = find_model_description(surf_new_model_description, new_model_name); surf_new_model_description[new_model_id].model_init_preparse(); /* ********************************************************************* */ }