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);
}
/* 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 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();
}
/* 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);
}
/* 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 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 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();
}
/* 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();
/* ********************************************************************* */
}
void update_model_description(s_surf_model_description_t * table,
const char *name, surf_model_t model)
{
int i = find_model_description(table, name);
table[i].model = model;
}
