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();
/* ********************************************************************* */
}
