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

static void action_init(const char *const *action){  int i;  XBT_DEBUG("Initialize the counters");  smpi_replay_globals_t globals =  xbt_new(s_smpi_replay_globals_t, 1);  globals->irecvs = xbt_dynar_new(sizeof(MPI_Request),NULL);  if(action[2]) MPI_DEFAULT_TYPE= MPI_DOUBLE; // default MPE dataype   else MPI_DEFAULT_TYPE= MPI_BYTE; // default TAU datatype  smpi_process_set_user_data((void*) globals);  /* start a simulated timer */  smpi_process_simulated_start();  /*initialize the number of active processes */  active_processes = smpi_process_count();  if (!reqq) {    reqq=xbt_new0(xbt_dynar_t,active_processes);    for(i=0;i<active_processes;i++){      reqq[i]=xbt_dynar_new(sizeof(MPI_Request),NULL);    }  }}

/* Business methods */xbt_dynar_t AsFloyd::getOneLinkRoutes(){  xbt_dynar_t ret = xbt_dynar_new(sizeof(OnelinkPtr), xbt_free_f);  sg_platf_route_cbarg_t route =   xbt_new0(s_sg_platf_route_cbarg_t, 1);  route->link_list = xbt_dynar_new(sizeof(sg_routing_link_t), NULL);  int src,dst;  sg_routing_edge_t src_elm, dst_elm;  int table_size = xbt_dynar_length(p_indexNetworkElm);  for(src=0; src < table_size; src++) {    for(dst=0; dst< table_size; dst++) {      xbt_dynar_reset(route->link_list);      src_elm = xbt_dynar_get_as(p_indexNetworkElm, src, RoutingEdgePtr);      dst_elm = xbt_dynar_get_as(p_indexNetworkElm, dst, RoutingEdgePtr);      this->getRouteAndLatency(src_elm, dst_elm, route, NULL);      if (xbt_dynar_length(route->link_list) == 1) {        void *link = *(void **) xbt_dynar_get_ptr(route->link_list, 0);        OnelinkPtr onelink;        if (p_hierarchy == SURF_ROUTING_BASE)          onelink = new Onelink(link, src_elm, dst_elm);        else if (p_hierarchy == SURF_ROUTING_RECURSIVE)          onelink = new Onelink(link, route->gw_src, route->gw_dst);        else          onelink = new Onelink(link, NULL, NULL);        xbt_dynar_push(ret, &onelink);      }    }  }  return ret;}

/** @brief shows some debugging info about the bucklet repartition */void xbt_dict_dump_sizes(xbt_dict_t dict){    int i;    unsigned int count;    unsigned int size;    xbt_dictelm_t element;    xbt_dynar_t sizes = xbt_dynar_new(sizeof(int), NULL);    printf("Dict %p: %d bucklets, %d used cells (of %d) ", dict, dict->count,           dict->fill, dict->table_size);    if (dict != NULL) {        for (i = 0; i < dict->table_size; i++) {            element = dict->table[i];            size = 0;            if (element) {                while (element != NULL) {                    size++;                    element = element->next;                }            }            if (xbt_dynar_length(sizes) <= size) {                int prevsize = 1;                xbt_dynar_set(sizes, size, &prevsize);            } else {                int prevsize;                xbt_dynar_get_cpy(sizes, size, &prevsize);                prevsize++;                xbt_dynar_set(sizes, size, &prevsize);            }        }        if (!all_sizes)            all_sizes = xbt_dynar_new(sizeof(int), NULL);        xbt_dynar_foreach(sizes, count, size) {            /* Copy values of this one into all_sizes */            int prevcount;            if (xbt_dynar_length(all_sizes) <= count) {                prevcount = size;                xbt_dynar_set(all_sizes, count, &prevcount);            } else {                xbt_dynar_get_cpy(all_sizes, count, &prevcount);                prevcount += size;                xbt_dynar_set(all_sizes, count, &prevcount);            }            /* Report current sizes */            if (count == 0)                continue;            if (size == 0)                continue;            printf("%uelm x %u cells; ", count, size);        }    }

static void action_init(const char *const *action){  XBT_DEBUG("Initialize the counters");  process_globals_t globals =      (process_globals_t) calloc(1, sizeof(s_process_globals_t));  globals->isends = xbt_dynar_new(sizeof(msg_comm_t), NULL);  globals->irecvs = xbt_dynar_new(sizeof(msg_comm_t), NULL);  globals->tasks = xbt_dynar_new(sizeof(msg_task_t), NULL);  MSG_process_set_data(MSG_process_self(), globals);}

static void action_init(const char *const *action){  XBT_DEBUG("Initialize the counters");  smpi_replay_globals_t globals =  xbt_new(s_smpi_replay_globals_t, 1);  globals->isends = xbt_dynar_new(sizeof(MPI_Request),NULL);  globals->irecvs = xbt_dynar_new(sizeof(MPI_Request),NULL);  smpi_process_set_user_data((void*) globals);  /* start a simulated timer */  smpi_process_simulated_start();  /*initialize the number of active processes */  active_processes = smpi_process_count();}

void mpi_init_(int* ierr) {   if(!comm_lookup){     comm_lookup = xbt_dynar_new(sizeof(MPI_Comm), NULL);     new_comm(MPI_COMM_WORLD);     group_lookup = xbt_dynar_new(sizeof(MPI_Group), NULL);     request_lookup = xbt_dict_new_homogeneous(NULL);     datatype_lookup = xbt_dynar_new(sizeof(MPI_Datatype), NULL);     new_datatype(MPI_BYTE);     new_datatype(MPI_CHAR);     new_datatype(MPI_INT);     new_datatype(MPI_INT);     new_datatype(MPI_INT8_T);     new_datatype(MPI_INT16_T);     new_datatype(MPI_INT32_T);     new_datatype(MPI_INT64_T);     new_datatype(MPI_FLOAT);     new_datatype(MPI_FLOAT);     new_datatype(MPI_DOUBLE);     new_datatype(MPI_DOUBLE);     new_datatype(MPI_C_FLOAT_COMPLEX);     new_datatype(MPI_C_DOUBLE_COMPLEX);     new_datatype(MPI_2INT);     new_datatype(MPI_UINT8_T);     new_datatype(MPI_UINT16_T);     new_datatype(MPI_UINT32_T);     new_datatype(MPI_UINT64_T);     new_datatype(MPI_2FLOAT);     new_datatype(MPI_2DOUBLE);     op_lookup = xbt_dynar_new(sizeof(MPI_Op), NULL);     new_op(MPI_MAX);     new_op(MPI_MIN);     new_op(MPI_MAXLOC);     new_op(MPI_MINLOC);     new_op(MPI_SUM);     new_op(MPI_PROD);     new_op(MPI_LAND);     new_op(MPI_LOR);     new_op(MPI_LXOR);     new_op(MPI_BAND);     new_op(MPI_BOR);     new_op(MPI_BXOR);   }   /* smpif2c is responsible for generating a call with the final arguments */   *ierr = MPI_Init(NULL, NULL);}

static xbt_dynar_t parse_factor(const char *smpi_coef_string){  char *value = NULL;  unsigned int iter = 0;  s_smpi_factor_t fact;  xbt_dynar_t smpi_factor, radical_elements, radical_elements2 = NULL;  smpi_factor = xbt_dynar_new(sizeof(s_smpi_factor_t), NULL);  radical_elements = xbt_str_split(smpi_coef_string, ";");  xbt_dynar_foreach(radical_elements, iter, value) {    radical_elements2 = xbt_str_split(value, ":");    surf_parse_assert(xbt_dynar_length(radical_elements2) == 2,        "Malformed radical '%s' for smpi factor. I was expecting something like 'a:b'", value);    char *errmsg = bprintf("Invalid factor in chunk #%d: %%s", iter+1);    fact.factor = xbt_str_parse_int(xbt_dynar_get_as(radical_elements2, 0, char *), errmsg);    xbt_free(errmsg);    fact.value = xbt_str_parse_double(xbt_dynar_get_as(radical_elements2, 1, char *), errmsg);    errmsg = bprintf("Invalid factor value in chunk #%d: %%s", iter+1);    xbt_free(errmsg);    xbt_dynar_push_as(smpi_factor, s_smpi_factor_t, fact);    XBT_DEBUG("smpi_factor:/t%ld : %f", fact.factor, fact.value);    xbt_dynar_free(&radical_elements2);  }

static void create_hierarchy(AS_t current_comp,                             jed_simgrid_container_t current_container){  xbt_dict_cursor_t cursor = NULL;  char *key;  AS_t elem;  xbt_dict_t routing_sons = surf_AS_get_routing_sons(current_comp);  if (xbt_dict_is_empty(routing_sons)) {    // I am no AS    // add hosts to jedule platform    xbt_dynar_t table = surf_AS_get_hosts(current_comp);    xbt_dynar_t hosts;    unsigned int dynar_cursor;    sg_host_t host_elem;    hosts = xbt_dynar_new(sizeof(char*), NULL);    xbt_dynar_foreach(table, dynar_cursor, host_elem) {      xbt_dynar_push_as(hosts, char*, sg_host_name(host_elem));    }    jed_simgrid_add_resources(current_container, hosts);    xbt_dynar_free(&hosts);    xbt_dynar_free(&table);  } else {

void jedule_log_sd_event(SD_task_t task){  xbt_dynar_t host_list;  jed_event_t event;  int i;  xbt_assert(task != NULL);  host_list = xbt_dynar_new(sizeof(char*), NULL);  for(i=0; i<task->workstation_nb; i++) {    char *hostname = sg_host_name(task->workstation_list[i]);    xbt_dynar_push(host_list, &hostname);  }  create_jed_event(&event,      (char*)SD_task_get_name(task),      task->start_time,      task->finish_time,      "SD");  jed_event_add_resources(event, host_list);  jedule_store_event(event);  xbt_dynar_free(&host_list);}

Cpu::Cpu(Model *model, simgrid::s4u::Host *host, lmm_constraint_t constraint,    xbt_dynar_t speedPeakList, int core, double speedPeak) : Resource(model, host->name().c_str(), constraint) , m_core(core) , m_host(host){  p_speed.peak = speedPeak;  p_speed.scale = 1;  host->pimpl_cpu = this;  xbt_assert(p_speed.scale > 0, "Available speed has to be >0");  // Copy the power peak array:  p_speedPeakList = xbt_dynar_new(sizeof(double), nullptr);  unsigned long n = xbt_dynar_length(speedPeakList);  for (unsigned long i = 0; i != n; ++i) {    double value = xbt_dynar_get_as(speedPeakList, i, double);    xbt_dynar_push(p_speedPeakList, &value);  }  /* Currently, we assume that a VM does not have a multicore CPU. */  if (core > 1)    xbt_assert(model == surf_cpu_model_pm);  if (model->getUpdateMechanism() != UM_UNDEFINED) {  p_constraintCore = xbt_new(lmm_constraint_t, core);  p_constraintCoreId = xbt_new(void*, core);    int i;    for (i = 0; i < core; i++) {      /* just for a unique id, never used as a string. */      p_constraintCoreId[i] = bprintf("%s:%i", host->name().c_str(), i);      p_constraintCore[i] = lmm_constraint_new(model->getMaxminSystem(), p_constraintCoreId[i], p_speed.scale * p_speed.peak);    }  }

/** * /brief Add a "host_link" to the network element list */static void parse_S_host_link(sg_platf_host_link_cbarg_t host){  sg_routing_edge_t info = NULL;  info = xbt_lib_get_or_null(host_lib, host->id, ROUTING_HOST_LEVEL);  xbt_assert(info, "Host '%s' not found!",host->id);  xbt_assert(current_routing->model_desc == &routing_models[SURF_MODEL_CLUSTER] ||      current_routing->model_desc == &routing_models[SURF_MODEL_VIVALDI],      "You have to be in model Cluster to use tag host_link!");  s_surf_parsing_link_up_down_t link_up_down;  link_up_down.link_up = xbt_lib_get_or_null(link_lib, host->link_up, SURF_LINK_LEVEL);  link_up_down.link_down = xbt_lib_get_or_null(link_lib, host->link_down, SURF_LINK_LEVEL);  link_up_down.limiter_link = NULL;  link_up_down.loopback_link = NULL;  xbt_assert(link_up_down.link_up, "Link '%s' not found!",host->link_up);  xbt_assert(link_up_down.link_down, "Link '%s' not found!",host->link_down);  if(!current_routing->link_up_down_list)    current_routing->link_up_down_list = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL);  // If dynar is is greater than edge id and if the host_link is already defined  if(xbt_dynar_length(current_routing->link_up_down_list) > info->id &&      xbt_dynar_get_as(current_routing->link_up_down_list,info->id,void*))    xbt_die("Host_link for '%s' is already defined!",host->id);  XBT_DEBUG("Push Host_link for host '%s' to position %d",info->name,info->id);  xbt_dynar_set_as(current_routing->link_up_down_list,info->id,s_surf_parsing_link_up_down_t,link_up_down);}

/* Build the set of hosts/VMs that have to be terminated. This function selects how_many VMs from the source set of * candidates. * Remark: In the paper by Malawski et al., no details are provided about how the VMs are selected in the source set. * Moreover, there is no check w.r.t. the size of the source set. * Assumptions: * 1) If the source set is too small, display a warning and return a smaller set than expected. * 2) Straightforward selection of the VMs in the set. Just pick the how_many first ones without any consideration of *    the time remaining until the next hourly billing cycle. Just check if the VM is not currently executing a task */xbt_dynar_t find_active_VMs_to_stop(int how_many, xbt_dynar_t source){  int i, found;  long unsigned int source_size = xbt_dynar_length(source);  xbt_dynar_t to_stop = xbt_dynar_new(sizeof(sg_host_t), NULL);  sg_host_t v;  if (how_many > source_size){    XBT_WARN("Trying to terminate more VMs than what is available (%d > %lu)."        " Change the number of VMs to terminate to %lu", how_many, source_size, source_size);    how_many = source_size;  }  i = 0;  found = 0;  while(found < how_many && i < xbt_dynar_length(source)){    /* No advanced selection process. Just pick the how_many first idle VMs in the source set. */    xbt_dynar_get_cpy(source, i, &v);    HostAttribute attr = sg_host_user(v);    if (!attr->idle_busy){      xbt_dynar_push(to_stop, &v);      found++;    }    i++;  }  if (found < how_many)    XBT_WARN("Trying to terminate too many VMs, some are busy... Change the number of VMs to terminate to %d", found);  return to_stop;}

static void action_init(const char *const *action){  XBT_DEBUG("Initialize the counters");  CHECK_ACTION_PARAMS(action, 0, 1);  if(action[2]) MPI_DEFAULT_TYPE= MPI_DOUBLE; // default MPE dataype   else MPI_DEFAULT_TYPE= MPI_BYTE; // default TAU datatype  /* start a simulated timer */  smpi_process_simulated_start();  /*initialize the number of active processes */  active_processes = smpi_process_count();  if (!reqq) {    reqq = xbt_dict_new();  }  set_reqq_self(xbt_dynar_new(sizeof(MPI_Request),&xbt_free_ref));  /*    reqq=xbt_new0(xbt_dynar_t,active_processes);    for(i=0;i<active_processes;i++){      reqq[i]=xbt_dynar_new(sizeof(MPI_Request),&xbt_free_ref);    }  }  */}

/** * /brief Add a "host" to the network element list */static void parse_S_host(sg_platf_host_cbarg_t host){  if (current_routing->p_hierarchy == SURF_ROUTING_NULL)    current_routing->p_hierarchy = SURF_ROUTING_BASE;  xbt_assert(!sg_host_by_name(host->id),		     "Reading a host, processing unit /"%s/" already exists", host->id);  RoutingEdge *info = new RoutingEdgeImpl(xbt_strdup(host->id),		                                    -1,		                                    SURF_NETWORK_ELEMENT_HOST,		                                    current_routing);  info->setId(current_routing->parsePU(info));  sg_host_edge_set(sg_host_by_name_or_create(host->id), info);  XBT_DEBUG("Having set name '%s' id '%d'", host->id, info->getId());  if(mount_list){    xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list);    mount_list = NULL;  }  if (host->coord && strcmp(host->coord, "")) {    unsigned int cursor;    char*str;    if (!COORD_HOST_LEVEL)      xbt_die ("To use host coordinates, please add --cfg=network/coordinates:yes to your command line");    /* Pre-parse the host coordinates -- FIXME factorize with routers by overloading the routing->parse_PU function*/    xbt_dynar_t ctn_str = xbt_str_split_str(host->coord, " ");    xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);    xbt_dynar_foreach(ctn_str,cursor, str) {      double val = atof(str);      xbt_dynar_push(ctn,&val);    }

ActionPtr NetworkCm02Model::communicate(RoutingEdgePtr src, RoutingEdgePtr dst,                                                double size, double rate){  unsigned int i;  void *_link;  NetworkCm02LinkPtr link;  int failed = 0;  NetworkCm02ActionPtr action = NULL;  double bandwidth_bound;  double latency = 0.0;  xbt_dynar_t back_route = NULL;  int constraints_per_variable = 0;  xbt_dynar_t route = xbt_dynar_new(sizeof(RoutingEdgePtr), NULL);  XBT_IN("(%s,%s,%g,%g)", src->getName(), dst->getName(), size, rate);  routing_platf->getRouteAndLatency(src, dst, &route, &latency);  xbt_assert(!xbt_dynar_is_empty(route) || latency,             "You're trying to send data from %s to %s but there is no connection at all between these two hosts.",             src->getName(), dst->getName());  xbt_dynar_foreach(route, i, _link) {	link = static_cast<NetworkCm02LinkPtr>(_link);    if (link->getState() == SURF_RESOURCE_OFF) {      failed = 1;      break;    }  }

static int master(int argc, char *argv[]){  msg_task_t task = NULL;  // I am the master of emigrant process,  // I tell it where it must emigrate to.  xbt_dynar_t destinations = xbt_dynar_new (sizeof(char*), &xbt_free_ref);  xbt_dynar_push_as (destinations, char*, xbt_strdup ("Tremblay"));  xbt_dynar_push_as (destinations, char*, xbt_strdup ("Jupiter"));  xbt_dynar_push_as (destinations, char*, xbt_strdup ("Fafard"));  xbt_dynar_push_as (destinations, char*, xbt_strdup ("Ginette"));  xbt_dynar_push_as (destinations, char*, xbt_strdup ("Bourassa"));  xbt_dynar_push_as (destinations, char*, xbt_strdup ("Fafard"));  xbt_dynar_push_as (destinations, char*, xbt_strdup ("Tremblay"));  xbt_dynar_push_as (destinations, char*, xbt_strdup ("Ginette"));  xbt_dynar_push_as (destinations, char*, NULL);  char *destination;  unsigned int i;  xbt_dynar_foreach(destinations, i, destination){    task = MSG_task_create("task", 0, 0, NULL);    if (destination){      MSG_task_set_data(task, xbt_strdup (destination));    }    MSG_task_set_category(task, "migration_order");    MSG_task_send (task, "master_mailbox");    task = NULL;  }

static void parse_ns3_add_link(sg_platf_link_cbarg_t link){  XBT_DEBUG("NS3_ADD_LINK '%s'",link->id);  if(!IPV4addr) IPV4addr = xbt_dynar_new(sizeof(char*),free);  tmgr_trace_t bw_trace;  tmgr_trace_t state_trace;  tmgr_trace_t lat_trace;  bw_trace = link->bandwidth_trace;  lat_trace = link->latency_trace;  state_trace = link->state_trace;  if (bw_trace)    XBT_INFO("The NS3 network model doesn't support bandwidth state traces");  if (lat_trace)    XBT_INFO("The NS3 network model doesn't support latency state traces");  if (state_trace)    XBT_INFO("The NS3 network model doesn't support link state traces");  ns3_link_t link_ns3 = xbt_new0(s_ns3_link_t,1);;  link_ns3->id = xbt_strdup((char*)(link->id));  link_ns3->bdw = bprintf("%f",link->bandwidth);  link_ns3->lat = bprintf("%f",link->latency);  surf_ns3_link_t l = xbt_new0(s_surf_ns3_link_t,1);  l->generic_resource.name = xbt_strdup(link->id);  l->generic_resource.properties = current_property_set;  l->data = link_ns3;  l->created = 1;  xbt_lib_set(link_lib,link->id,NS3_LINK_LEVEL,link_ns3);  xbt_lib_set(link_lib,link->id,SURF_LINK_LEVEL,l);}

void peer_init(peer_t p, int argc, char *argv[]){  p->init = 0;  p->prev = NULL;  p->next = NULL;  p->pieces = 0;  p->bytes = 0;  p->pending_recvs = xbt_dynar_new(sizeof(msg_comm_t), NULL);  p->pending_sends = xbt_dynar_new(sizeof(msg_comm_t), NULL);  /* Set mailbox name: use host number from argv or hostname if no argument given */  if (argc > 1) {    p->me = bprintf("host%s", argv[1]);  } else {    p->me = xbt_strdup(MSG_host_get_name(MSG_host_self()));  }}

/** * /brief Add a "host_link" to the network element list */static void parse_S_host_link(sg_platf_host_link_cbarg_t host){  RoutingEdge *info = sg_host_edge(sg_host_by_name(host->id));  xbt_assert(info, "Host '%s' not found!", host->id);  xbt_assert(current_routing->p_modelDesc == &routing_models[SURF_MODEL_CLUSTER] ||      current_routing->p_modelDesc == &routing_models[SURF_MODEL_VIVALDI],      "You have to be in model Cluster to use tag host_link!");  s_surf_parsing_link_up_down_t link_up_down;  link_up_down.link_up = Link::byName(host->link_up);  link_up_down.link_down = Link::byName(host->link_down);  xbt_assert(link_up_down.link_up, "Link '%s' not found!",host->link_up);  xbt_assert(link_up_down.link_down, "Link '%s' not found!",host->link_down);  if(!current_routing->p_linkUpDownList)    current_routing->p_linkUpDownList = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL);  // If dynar is is greater than edge id and if the host_link is already defined  if((int)xbt_dynar_length(current_routing->p_linkUpDownList) > info->getId() &&      xbt_dynar_get_as(current_routing->p_linkUpDownList, info->getId(), void*))	surf_parse_error("Host_link for '%s' is already defined!",host->id);  XBT_DEBUG("Push Host_link for host '%s' to position %d", info->getName(), info->getId());  xbt_dynar_set_as(current_routing->p_linkUpDownList, info->getId(), s_surf_parsing_link_up_down_t, link_up_down);}

/** @brief Add an "host" to the current AS */void sg_platf_new_host(sg_platf_host_cbarg_t host){  xbt_assert(! sg_host_by_name(host->id),      "Refusing to create a second host named '%s'.", host->id);  simgrid::surf::AsImpl* current_routing = routing_get_current();  if (current_routing->hierarchy_ == simgrid::surf::AsImpl::RoutingMode::unset)    current_routing->hierarchy_ = simgrid::surf::AsImpl::RoutingMode::base;  simgrid::surf::NetCard *netcard =      new simgrid::surf::NetCardImpl(host->id, SURF_NETWORK_ELEMENT_HOST, current_routing);  netcard->setId(current_routing->addComponent(netcard));  sg_host_t h = simgrid::s4u::Host::by_name_or_create(host->id);  h->pimpl_netcard = netcard;  simgrid::surf::netcardCreatedCallbacks(netcard);  if(mount_list){    xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list);    mount_list = NULL;  }  if (host->coord && strcmp(host->coord, "")) {    unsigned int cursor;    char*str;    if (!COORD_HOST_LEVEL)      xbt_die ("To use host coordinates, please add --cfg=network/coordinates:yes to your command line");    /* Pre-parse the host coordinates -- FIXME factorize with routers by overloading the routing->parse_PU function*/    xbt_dynar_t ctn_str = xbt_str_split_str(host->coord, " ");    xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);    xbt_dynar_foreach(ctn_str,cursor, str) {      double val = xbt_str_parse_double(str, "Invalid coordinate: %s");      xbt_dynar_push(ctn,&val);    }

static void parse_ns3_add_cluster(sg_platf_cluster_cbarg_t cluster){  const char *cluster_prefix = cluster->prefix;  const char *cluster_suffix = cluster->suffix;  const char *cluster_radical = cluster->radical;  const char *cluster_bb_bw = bprintf("%f",cluster->bb_bw);  const char *cluster_bb_lat = bprintf("%f",cluster->bb_lat);  const char *cluster_bw = bprintf("%f",cluster->bw);  const char *cluster_lat = bprintf("%f",cluster->lat);  const char *groups = NULL;  int start, end, i;  unsigned int iter;  xbt_dynar_t radical_elements;  xbt_dynar_t radical_ends;  xbt_dynar_t tab_elements_num = xbt_dynar_new(sizeof(int), NULL);  char *router_id,*host_id;  radical_elements = xbt_str_split(cluster_radical, ",");  xbt_dynar_foreach(radical_elements, iter, groups) {    radical_ends = xbt_str_split(groups, "-");    switch (xbt_dynar_length(radical_ends)) {    case 1:      start = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *));      xbt_dynar_push_as(tab_elements_num, int, start);      router_id = bprintf("ns3_%s%d%s", cluster_prefix, start, cluster_suffix);      xbt_lib_set(host_lib,                  router_id,                  NS3_HOST_LEVEL,                  ns3_add_host_cluster(router_id)        );      XBT_DEBUG("NS3_ADD_ROUTER '%s'",router_id);      free(router_id);      break;    case 2:      start = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *));      end = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 1, char *));      for (i = start; i <= end; i++){        xbt_dynar_push_as(tab_elements_num, int, i);        router_id = bprintf("ns3_%s%d%s", cluster_prefix, i, cluster_suffix);        xbt_lib_set(host_lib,                    router_id,                    NS3_HOST_LEVEL,                    ns3_add_host_cluster(router_id)          );        XBT_DEBUG("NS3_ADD_ROUTER '%s'",router_id);        free(router_id);      }      break;    default:      XBT_DEBUG("Malformed radical");    }  }

static xbt_dynar_t rulebased_get_onelink_routes(AS_t rc){  xbt_dynar_t ret = xbt_dynar_new (sizeof(onelink_t), xbt_free);  //We have already bypass cluster routes with network NS3  if(!strcmp(surf_network_model->name,"network NS3"))    return ret;  char *k1;  //find router  sg_routing_edge_t router = NULL;  xbt_lib_cursor_t cursor;  xbt_lib_foreach(as_router_lib, cursor, k1, router)  {    if (router->rc_type == SURF_NETWORK_ELEMENT_ROUTER)      break;  }  if (!router)    xbt_die ("rulebased_get_onelink_routes works only if the AS is a cluster, sorry.");  sg_routing_edge_t host = NULL;  xbt_lib_foreach(as_router_lib, cursor, k1, host){    void *link_ptr;    sg_platf_route_cbarg_t route = xbt_new0(s_sg_platf_route_cbarg_t,1);    route->link_list = xbt_dynar_new(sizeof(sg_routing_link_t),NULL);    rulebased_get_route_and_latency (rc, router, host, route,NULL);    switch (xbt_dynar_length(route->link_list)) {    case 1:      //loopback      break;    case 2:      xbt_dynar_get_cpy (route->link_list, 1, &link_ptr);      onelink_t onelink = xbt_new0 (s_onelink_t, 1);      onelink->src = host;      onelink->dst = router;      onelink->link_ptr = link_ptr;      xbt_dynar_push (ret, &onelink);      break;    default:      xbt_die("rulebased_get_onelink_routes works only if the AS is a cluster, sorry.");      break;    }  }

LinkDynar getRoute(char *srcName, char *dstName) {  RoutingEdge *src = sg_host_edge(sg_host_by_name(srcName));  RoutingEdge *dst = sg_host_edge(sg_host_by_name(dstName));  xbt_assert(src,"Cannot get the route from a NULL source");  xbt_assert(dst,"Cannot get the route to a NULL destination");  xbt_dynar_t route = xbt_dynar_new(sizeof(RoutingEdge*), NULL);  routing_platf->getRouteAndLatency(src, dst, &route, NULL);  return route;}

int master_fun(int argc, char *argv[]){  msg_vm_t vm;  unsigned int i;  xbt_dynar_t worker_pms = MSG_process_get_data(MSG_process_self());  int nb_workers = xbt_dynar_length(worker_pms);  xbt_dynar_t vms = xbt_dynar_new(sizeof(msg_vm_t), NULL);  /* Launch VMs and worker processes. One VM per PM, and one worker process per VM. */  XBT_INFO("# Launch %d VMs", nb_workers);  for (i = 0; i< nb_workers; i++) {    char *vm_name = bprintf("VM%02d", i);    char *pr_name = bprintf("WRK%02d", i);    msg_host_t pm = xbt_dynar_get_as(worker_pms, i, msg_host_t);    XBT_INFO("create %s on PM(%s)", vm_name, MSG_host_get_name(pm));    msg_vm_t vm = MSG_vm_create_core(pm, vm_name);    s_vm_params_t params;    memset(&params, 0, sizeof(params));    params.ramsize = 1L * 1024 * 1024 * 1024; // 1Gbytes    MSG_host_set_params(vm, &params);    MSG_vm_start(vm);    xbt_dynar_push(vms, &vm);    XBT_INFO("put a process (%s) on %s", pr_name, vm_name);    MSG_process_create(pr_name, worker_fun, NULL, vm);    xbt_free(vm_name);    xbt_free(pr_name);  }  /* Send a bunch of work to every one */  XBT_INFO("# Send a task to %d worker process", nb_workers);  send_tasks(nb_workers);  XBT_INFO("# Suspend all VMs");  xbt_dynar_foreach(vms, i, vm) {    const char *vm_name = MSG_host_get_name(vm);    XBT_INFO("suspend %s", vm_name);    MSG_vm_suspend(vm);  }  XBT_INFO("# Wait a while");  MSG_process_sleep(2);  XBT_INFO("# Resume all VMs");  xbt_dynar_foreach(vms, i, vm) {    MSG_vm_resume(vm);  }

/** Sender function  */int sender(int argc, char *argv[]){  long number_of_tasks = atol(argv[1]);  double task_comp_size = atof(argv[2]);  double task_comm_size = atof(argv[3]);  long receivers_count = atol(argv[4]);  int diff_com = atol(argv[5]);  double coef = 0;  xbt_dynar_t d = xbt_dynar_new(sizeof(msg_comm_t), NULL);  int i;  msg_task_t task;  char mailbox[256];  char sprintf_buffer[256];  msg_comm_t comm;  for (i = 0; i < number_of_tasks; i++) {    if (diff_com == 0)      coef = 1;    else      coef = (i + 1);    sprintf(mailbox, "receiver-%ld", (i % receivers_count));    sprintf(sprintf_buffer, "Task_%d", i);    task =        MSG_task_create(sprintf_buffer, task_comp_size,                        task_comm_size / coef, NULL);    comm = MSG_task_isend(task, mailbox);    xbt_dynar_push_as(d, msg_comm_t, comm);    XBT_INFO("Send to receiver-%ld %s comm_size %f", i % receivers_count,          sprintf_buffer, task_comm_size / coef);  }  /* Here we are waiting for the completion of all communications */  while (!xbt_dynar_is_empty(d)) {    xbt_dynar_remove_at(d, MSG_comm_waitany(d), &comm);    MSG_comm_destroy(comm);  }  xbt_dynar_free(&d);  /* Here we are waiting for the completion of all tasks */  sprintf(mailbox, "finalize");  msg_comm_t res_irecv;  _XBT_GNUC_UNUSED msg_error_t res_wait;  for (i = 0; i < receivers_count; i++) {    task = NULL;    res_irecv = MSG_task_irecv(&(task), mailbox);    res_wait = MSG_comm_wait(res_irecv, -1);    xbt_assert(res_wait == MSG_OK, "MSG_comm_wait failed");    MSG_comm_destroy(res_irecv);    MSG_task_destroy(task);  }  XBT_INFO("Goodbye now!");  return 0;}                               /* end_of_sender */

static void action_waitall(const char *const *action){  double clock = smpi_process_simulated_elapsed();  int count_requests=0;  unsigned int i=0;  count_requests=xbt_dynar_length(reqq[smpi_comm_rank(MPI_COMM_WORLD)]);  if (count_requests>0) {    MPI_Request requests[count_requests];    MPI_Status status[count_requests];    /*  The reqq is an array of dynars. Its index corresponds to the rank.     Thus each rank saves its own requests to the array request. */    xbt_dynar_foreach(reqq[smpi_comm_rank(MPI_COMM_WORLD)],i,requests[i]);   #ifdef HAVE_TRACING   //save information from requests   xbt_dynar_t srcs = xbt_dynar_new(sizeof(int), NULL);   xbt_dynar_t dsts = xbt_dynar_new(sizeof(int), NULL);   xbt_dynar_t recvs = xbt_dynar_new(sizeof(int), NULL);   for (i = 0; i < count_requests; i++) {    if(requests[i]){      int *asrc = xbt_new(int, 1);      int *adst = xbt_new(int, 1);      int *arecv = xbt_new(int, 1);      *asrc = requests[i]->src;      *adst = requests[i]->dst;      *arecv = requests[i]->recv;      xbt_dynar_insert_at(srcs, i, asrc);      xbt_dynar_insert_at(dsts, i, adst);      xbt_dynar_insert_at(recvs, i, arecv);      xbt_free(asrc);      xbt_free(adst);      xbt_free(arecv);    }else {      int *t = xbt_new(int, 1);      xbt_dynar_insert_at(srcs, i, t);      xbt_dynar_insert_at(dsts, i, t);      xbt_dynar_insert_at(recvs, i, t);      xbt_free(t);    }   }

static void array_new(unsigned **a, xbt_dynar_t *data){  int i;  *a = xbt_malloc(ARRAY_SIZE * sizeof **a);  *data = xbt_dynar_new(sizeof *a, NULL);  xbt_dynar_shrink(*data, ARRAY_SIZE);  for (i = 0 ; i < ARRAY_SIZE ; i++) {    (*a)[i] = i;    xbt_dynar_push_as(*data, void*, &(*a)[i]);  }}

/** @brief Returns the dynar of the parents of a task * * /param task a task * /return a newly allocated dynar comprising the parents of this task */xbt_dynar_t SD_task_get_children(SD_task_t task){  xbt_dynar_t children = xbt_dynar_new(sizeof(SD_task_t), nullptr);  for (std::set<SD_task_t>::iterator it=task->successors->begin(); it!=task->successors->end(); ++it)    xbt_dynar_push(children, &(*it));  for (std::set<SD_task_t>::iterator it=task->outputs->begin(); it!=task->outputs->end(); ++it)    xbt_dynar_push(children, &(*it));  return children;}

static xbt_dynar_t instr_dict_to_dynar (xbt_dict_t filter){  if (!TRACE_is_enabled()) return NULL;  if (!TRACE_needs_platform()) return NULL;  xbt_dynar_t ret = xbt_dynar_new (sizeof(char*), &xbt_free_ref);  xbt_dict_cursor_t cursor = NULL;  char *name, *value;  xbt_dict_foreach(filter, cursor, name, value) {    xbt_dynar_push_as (ret, char*, xbt_strdup(name));  }

void jed_event_add_resources(jed_event_t event, xbt_dynar_t host_selection) {  xbt_dynar_t resource_subset_list;  jed_res_subset_t res_set;  unsigned int i;  resource_subset_list = xbt_dynar_new(sizeof(jed_res_subset_t), NULL);  jed_simgrid_get_resource_selection_by_hosts(resource_subset_list, host_selection);  xbt_dynar_foreach(resource_subset_list, i, res_set)  {    xbt_dynar_push(event->resource_subsets, &res_set);  }