自学教程：C++ xbt_cfg_get_string函数代码示例

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);}

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

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

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