コード例 #1
0
ファイル: instr_config.c プロジェクト: Shurakai/SimGrid
int TRACE_start()
{
  TRACE_getopts();

  // tracing system must be:
  //    - enabled (with --cfg=tracing:1)
  //    - already configured (TRACE_global_init already called)
  if (!(TRACE_is_enabled() && TRACE_is_configured())){
    return 0;
  }

  XBT_DEBUG("Tracing starts");

  /* open the trace file */
  TRACE_paje_start();

  /* 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);
  declared_marks = xbt_dict_new_homogeneous (xbt_free);
  user_host_variables = xbt_dict_new_homogeneous (xbt_free);
  user_link_variables = xbt_dict_new_homogeneous (xbt_free);
  TRACE_surf_alloc();
  TRACE_smpi_alloc();
  return 0;
}
コード例 #2
0
ファイル: xbt_replay.c プロジェクト: apargupta/simgrid
/** @brief Initializes the replay mechanism, and returns true if (and only if) it was necessary
 *
 * It returns false if it was already done by another process.
 */
int _xbt_replay_action_init(void)
{
  if (xbt_action_funs)
	  return 0;
  is_replay_active = 1;
  xbt_action_funs = xbt_dict_new_homogeneous(NULL);
  xbt_action_queues = xbt_dict_new_homogeneous(NULL);
  return 1;
}
コード例 #3
0
ファイル: instr_config.c プロジェクト: FlorianPO/simgrid
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 = sg_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_length(TRACE_start_functions);
      xbt_dynar_foreach(TRACE_start_functions, iter, func) {
        func();
      }
    }
  }
コード例 #4
0
ファイル: network_smpi.cpp プロジェクト: simgrid/simgrid
void NetworkSmpiModel::gapAppend(double size, Link* link, NetworkAction *act)
{
    const char *src = link->getName();
    xbt_fifo_t fifo;
    NetworkCm02Action *action= static_cast<NetworkCm02Action*>(act);

    if (sg_sender_gap > 0.0) {
        if (!gap_lookup) {
            gap_lookup = xbt_dict_new_homogeneous(nullptr);
        }
        fifo = (xbt_fifo_t) xbt_dict_get_or_null(gap_lookup, src);
        action->senderGap_ = 0.0;
        if (fifo && xbt_fifo_size(fifo) > 0) {
            /* Compute gap from last send */
            /*last_action =
            (surf_action_network_CM02_t)
            xbt_fifo_get_item_content(xbt_fifo_get_last_item(fifo));*/
            // bw = net_get_link_bandwidth(link);
            action->senderGap_ = sg_sender_gap;
            /*  max(sg_sender_gap,last_action->sender.size / bw);*/
            action->latency_ += action->senderGap_;
        }
        /* Append action as last send */
        /*action->sender.link_name = link->lmm_resource.generic_resource.name;
        fifo =
        (xbt_fifo_t) xbt_dict_get_or_null(gap_lookup,
                                          action->sender.link_name);
        if (!fifo) {
        fifo = xbt_fifo_new();
        xbt_dict_set(gap_lookup, action->sender.link_name, fifo, nullptr);
        }
        action->sender.fifo_item = xbt_fifo_push(fifo, action);*/
        action->senderSize_ = size;
    }
}
コード例 #5
0
ファイル: msg_host.c プロジェクト: Julio-Anjos/simgrid
/********************************* Host **************************************/
msg_host_t __MSG_host_create(smx_host_t workstation)
{
  const char *name = SIMIX_host_get_name(workstation);
  msg_host_priv_t priv = xbt_new0(s_msg_host_priv_t, 1);

#ifdef MSG_USE_DEPRECATED
  int i;
  char alias[MAX_ALIAS_NAME + 1] = { 0 };       /* buffer used to build the key of the mailbox */

  priv->mailboxes = (msg_global->max_channel > 0) ?
    xbt_new0(msg_mailbox_t, msg_global->max_channel) : NULL;

  for (i = 0; i < msg_global->max_channel; i++) {
    sprintf(alias, "%s:%d", name, i);

    /* the key of the mailbox (in this case) is build from the name of the host and the channel number */
    priv->mailboxes[i] = MSG_mailbox_new(alias);
    memset(alias, 0, MAX_ALIAS_NAME + 1);
  }
#endif


  priv->dp_objs = xbt_dict_new();
  priv->dp_enabled = 0;
  priv->dp_updated_by_deleted_tasks = 0;
  priv->is_migrating = 0;

  priv->affinity_mask_db = xbt_dict_new_homogeneous(NULL);

  xbt_lib_set(host_lib, name, MSG_HOST_LEVEL, priv);
  
  return xbt_lib_get_elm_or_null(host_lib, name);
}
コード例 #6
0
int main(int argc, char *argv[]) {
  msg_error_t res = MSG_OK;

  MSG_init(&argc, argv);
  /* Explicit initialization of the action module is required now*/
  MSG_action_init();

  xbt_assert(argc > 3,"Usage: %s platform_file deployment_file [action_files]\n"
             "\texample: %s platform.xml deployment.xml actions # if all actions are in the same file\n"
             "\texample: %s platform.xml deployment.xml # if actions are in separate files, specified in deployment\n",
             argv[0], argv[0], argv[0]);

  MSG_create_environment(argv[1]);
  MSG_launch_application(argv[2]);

  /*   Action registration */
  xbt_replay_action_register("open", action_open);
  xbt_replay_action_register("read", action_read);
  xbt_replay_action_register("close", action_close);

  if (!opened_files)
    opened_files = xbt_dict_new_homogeneous(NULL);
  /* Actually do the simulation using MSG_action_trace_run */
  res = MSG_action_trace_run(argv[3]);  // it's ok to pass a NULL argument here

  XBT_INFO("Simulation time %g", MSG_get_clock());

  if (opened_files)
    xbt_dict_free(&opened_files);

  /* Explicit finalization of the action module is required now*/
  MSG_action_exit();

  return res!=MSG_OK;
}
コード例 #7
0
ファイル: msg_task.c プロジェクト: tempbottle/simgrid
/** \ingroup m_task_management
 * \brief Creates a new #msg_task_t.
 *
 * A constructor for #msg_task_t taking four arguments and returning the
   corresponding object.
 * \param name a name for the object. It is for user-level information
   and can be NULL.
 * \param flop_amount a value of the processing amount (in flop)
   needed to process this new task. If 0, then it cannot be executed with
   MSG_task_execute(). This value has to be >=0.
 * \param message_size a value of the amount of data (in bytes) needed to
   transfer this new task. If 0, then it cannot be transfered with
   MSG_task_send() and MSG_task_recv(). This value has to be >=0.
 * \param data a pointer to any data may want to attach to the new
   object.  It is for user-level information and can be NULL. It can
   be retrieved with the function \ref MSG_task_get_data.
 * \see msg_task_t
 * \return The new corresponding object.
 */
msg_task_t MSG_task_create(const char *name, double flop_amount,
                         double message_size, void *data)
{
  msg_task_t task = xbt_new(s_msg_task_t, 1);
  simdata_task_t simdata = xbt_new(s_simdata_task_t, 1);
  task->simdata = simdata;

  /* Task structure */
  task->name = xbt_strdup(name);
  task->data = data;

  /* Simulator Data */
  simdata->compute = NULL;
  simdata->comm = NULL;
  simdata->bytes_amount = message_size;
  simdata->flops_amount = flop_amount;
  simdata->sender = NULL;
  simdata->receiver = NULL;
  simdata->source = NULL;
  simdata->priority = 1.0;
  simdata->bound = 0;
  simdata->affinity_mask_db = xbt_dict_new_homogeneous(NULL);
  simdata->rate = -1.0;
  simdata->isused = 0;

  simdata->host_nb = 0;
  simdata->host_list = NULL;
  simdata->flops_parallel_amount = NULL;
  simdata->bytes_parallel_amount = NULL;
  TRACE_msg_task_create(task);

  return task;
}
コード例 #8
0
ファイル: msg_task.c プロジェクト: Julio-Anjos/simgrid
/** \ingroup m_task_management
 * \brief Creates a new #msg_task_t.
 *
 * A constructor for #msg_task_t taking four arguments and returning the
   corresponding object.
 * \param name a name for the object. It is for user-level information
   and can be NULL.
 * \param compute_duration a value of the processing amount (in flop)
   needed to process this new task. If 0, then it cannot be executed with
   MSG_task_execute(). This value has to be >=0.
 * \param message_size a value of the amount of data (in bytes) needed to
   transfer this new task. If 0, then it cannot be transfered with
   MSG_task_send() and MSG_task_recv(). This value has to be >=0.
 * \param data a pointer to any data may want to attach to the new
   object.  It is for user-level information and can be NULL. It can
   be retrieved with the function \ref MSG_task_get_data.
 * \see msg_task_t
 * \return The new corresponding object.
 */
msg_task_t MSG_task_create(const char *name, double compute_duration,
                         double message_size, void *data)
{
  msg_task_t task = xbt_new(s_msg_task_t, 1);
  simdata_task_t simdata = xbt_new(s_simdata_task_t, 1);
  task->simdata = simdata;

  /* Task structure */
  task->name = xbt_strdup(name);
  task->data = data;

  /* Simulator Data */
  simdata->compute = NULL;
  simdata->comm = NULL;
  simdata->message_size = message_size;
  simdata->computation_amount = compute_duration;
  simdata->sender = NULL;
  simdata->receiver = NULL;
  simdata->source = NULL;
  simdata->priority = 1.0;
  simdata->bound = 0;
  simdata->affinity_mask_db = xbt_dict_new_homogeneous(NULL);
  simdata->rate = -1.0;
  simdata->isused = 0;

  simdata->host_nb = 0;
  simdata->host_list = NULL;
  simdata->comp_amount = NULL;
  simdata->comm_amount = NULL;
#ifdef HAVE_TRACING
  TRACE_msg_task_create(task);
#endif

  return task;
}
コード例 #9
0
void print_TICreateContainer(paje_event_t event)
{
  //if we are in the mode with only one file
  static FILE *temp = nullptr;

  if (tracing_files == nullptr) {
    tracing_files = xbt_dict_new_homogeneous(nullptr);
    //generate unique run id with time
    prefix = xbt_os_time();
  }

  if (!xbt_cfg_get_boolean("tracing/smpi/format/ti-one-file") || temp == nullptr) {
    char *folder_name = bprintf("%s_files", TRACE_get_filename());
    char *filename = bprintf("%s/%f_%s.txt", folder_name, prefix, ((createContainer_t) event->data)->container->name);
#ifdef WIN32
    _mkdir(folder_name);
#else
    mkdir(folder_name, S_IRWXU | S_IRWXG | S_IRWXO);
#endif
    temp = fopen(filename, "w");
    xbt_assert(temp, "Tracefile %s could not be opened for writing: %s", filename, strerror(errno));
    fprintf(tracing_file, "%s\n", filename);

    xbt_free(folder_name);
    xbt_free(filename);
  }

  xbt_dict_set(tracing_files, ((createContainer_t) event->data)->container->name, (void *) temp, nullptr);
}
コード例 #10
0
ファイル: dict.c プロジェクト: apargupta/simgrid
/**
 * \brief Constructor
 * \return pointer to the destination
 * \see xbt_dict_free()
 *
 * Creates and initialize a new dictionary with a default hashtable size.
 * The dictionary is heterogeneous: each element can have a different free
 * function.
 */
xbt_dict_t xbt_dict_new(void)
{
    xbt_dict_t dict = xbt_dict_new_homogeneous(NULL);
    dict->homogeneous = 0;

    return dict;
}
コード例 #11
0
ファイル: msg_host.c プロジェクト: tempbottle/simgrid
/********************************* Host **************************************/
msg_host_t __MSG_host_create(sg_host_t host) // FIXME: don't return our parameter
{
  msg_host_priv_t priv = xbt_new0(s_msg_host_priv_t, 1);

#ifdef MSG_USE_DEPRECATED
  int i;
  char alias[MAX_ALIAS_NAME + 1] = { 0 };       /* buffer used to build the key of the mailbox */

  priv->mailboxes = (msg_global->max_channel > 0) ?
    xbt_new0(msg_mailbox_t, msg_global->max_channel) : NULL;

  for (i = 0; i < msg_global->max_channel; i++) {
    sprintf(alias, "%s:%d", name, i);

    /* the key of the mailbox (in this case) is build from the name of the host and the channel number */
    priv->mailboxes[i] = MSG_mailbox_new(alias);
    memset(alias, 0, MAX_ALIAS_NAME + 1);
  }
#endif


  priv->dp_objs = xbt_dict_new();
  priv->dp_enabled = 0;
  priv->dp_updated_by_deleted_tasks = 0;
  priv->is_migrating = 0;

  priv->affinity_mask_db = xbt_dict_new_homogeneous(NULL);

  sg_host_msg_set(host,priv);
  
  return host;
}
コード例 #12
0
ファイル: sd_dotloader.c プロジェクト: apargupta/simgrid
/** @brief loads a DOT file describing a DAG
 * 
 * See http://www.graphviz.org/doc/info/lang.html
 * for more details.
 * To obtain information about transfers and tasks, two attributes are
 * required : size on task (execution time in Flop) and size on edge
 * (the amount of data transfer in bit).
 * if they aren't here, there choose to be equal to zero.
 */
xbt_dynar_t SD_dotload(const char *filename) {
  computers = xbt_dict_new_homogeneous(NULL);
  schedule = false;
  SD_dotload_generic(filename, sequential);
  xbt_dynar_t computer = NULL;
  xbt_dict_cursor_t dict_cursor;
  char *computer_name;
  xbt_dict_foreach(computers,dict_cursor,computer_name,computer){
    xbt_dynar_free(&computer);
  }
コード例 #13
0
ファイル: smpi_bench.c プロジェクト: Shurakai/SimGrid
void* smpi_shared_set_call(const char* func, const char* input, void* data) {
   char* loc = bprintf("%s:%s", func, input);

   if(!calls) {
      calls = xbt_dict_new_homogeneous(NULL);
   }
   xbt_dict_set(calls, loc, data, NULL);
   free(loc);
   return data;
}
コード例 #14
0
ファイル: surfxml_parse.c プロジェクト: ricardojrdez/simgrid
void STag_surfxml_prop(void)
{
  if(AS_TAG){
    if (!as_current_property_set){
      xbt_assert(as_prop_nb < 1024, "Number of AS property reach the limit!!!");
      as_current_property_set = xbt_dict_new_homogeneous(xbt_free_f); // Maybe, it should raise an error
      as_name_tab[as_prop_nb] = xbt_strdup(A_surfxml_AS_id);
      as_dict_tab[as_prop_nb] = as_current_property_set;
      XBT_DEBUG("PUSH prop %p for AS '%s'",as_dict_tab[as_prop_nb],as_name_tab[as_prop_nb]);
      as_prop_nb++;
    }
    xbt_dict_set(as_current_property_set, A_surfxml_prop_id, xbt_strdup(A_surfxml_prop_value), NULL);
  }
  else{
    if (!current_property_set)
      current_property_set = xbt_dict_new_homogeneous(xbt_free_f); // Maybe, it should raise an error
    xbt_dict_set(current_property_set, A_surfxml_prop_id, xbt_strdup(A_surfxml_prop_value), NULL);
  }
}
コード例 #15
0
xbt_dict_t Storage::getContent()
{
  /* For the moment this action has no cost, but in the future we could take in account access latency of the disk */

  xbt_dict_t content_dict = xbt_dict_new_homogeneous(NULL);
  xbt_dict_cursor_t cursor = NULL;
  char *file;
  sg_size_t *psize;

  xbt_dict_foreach(p_content, cursor, file, psize){
    xbt_dict_set(content_dict,file,psize,NULL);
  }
コード例 #16
0
ファイル: extracttrace.c プロジェクト: congfairy/simulator
int main(int argc, char *argv[]) {
  /* Check the given arguments */
  MSG_init(&argc, argv);
  /* Explicit initialization of the action module is required now*/
  MSG_action_init();
 // MSG_config("surf/precision","1e-9");
  MSG_create_environment(argv[1]);
 /*  Simulation setting */
  msg_error_t res = MSG_OK;

  /* No need to register functions as in classical MSG programs: the actions get started anyway */
  MSG_launch_application(argv[2]);
  char *wh=argv[4];
  XBT_INFO("Your choose is %s",wh);
  xbt_replay_action_register("unlink", simsleep);//register the action
  xbt_replay_action_register("compute", simsleep);//register the action
  xbt_replay_action_register("access", simsleep);
  xbt_replay_action_register("stat", simsleep);
  xbt_replay_action_register("flush", simsleep);
  xbt_replay_action_register("readdir", simsleep);
  xbt_replay_action_register("getxattr", simsleep);
  xbt_replay_action_register("mkdir", simsleep);
  xbt_replay_action_register("symlink", simsleep);
  xbt_replay_action_register("readlink", simsleep);
  if(strcmp(wh,"action")==0) //decide which mode to run
  /*   Action registration */
 {
  xbt_replay_action_register("open", simopen);
  xbt_replay_action_register("release", simrelease);
  xbt_replay_action_register("read", simread);
  xbt_replay_action_register("creat", simcreat);
  xbt_replay_action_register("write", simwrite);
 }
  else if(strcmp(wh,"sleep")==0){
  xbt_replay_action_register("open", simsleep);
  xbt_replay_action_register("release", simsleep);
  xbt_replay_action_register("read", simsleep);
  xbt_replay_action_register("creat", simsleep);
  xbt_replay_action_register("write", simsleep);
  }
 
  if(!opened_files)
  {opened_files = xbt_dict_new_homogeneous(NULL);}
  res = MSG_action_trace_run(argv[3]);  // it's ok to pass a NULL argument here

  XBT_INFO("Simulation time %g", MSG_get_clock());
  if(opened_files)
	{xbt_dict_free(&opened_files);}
 MSG_action_exit();
  return !!MSG_OK;
}
コード例 #17
0
ファイル: smpi_f77.c プロジェクト: ricardojrdez/simgrid
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);
}
コード例 #18
0
ファイル: msg_host.c プロジェクト: tempbottle/simgrid
/** \ingroup m_host_management
 * \brief Return the content of mounted storages on an host.
 * \param host a host
 * \return a dict containing content (as a dict) of all storages mounted on the host
 */
xbt_dict_t MSG_host_get_storage_content(msg_host_t host)
{
  xbt_assert((host != NULL), "Invalid parameters");
  xbt_dict_t contents = xbt_dict_new_homogeneous(NULL);
  msg_storage_t storage;
  char* storage_name;
  char* mount_name;
  xbt_dict_cursor_t cursor = NULL;

  xbt_dict_t storage_list = simcall_host_get_mounted_storage_list(host);

  xbt_dict_foreach(storage_list,cursor,mount_name,storage_name){
    storage = (msg_storage_t)xbt_lib_get_elm_or_null(storage_lib,storage_name);
    xbt_dict_t content = simcall_storage_get_content(storage);
    xbt_dict_set(contents,mount_name, content,NULL);
  }
コード例 #19
0
ファイル: smpi_bench.c プロジェクト: Shurakai/SimGrid
void *smpi_shared_malloc(size_t size, const char *file, int line)
{
  char *loc = bprintf("%zu_%s_%d", (size_t)getpid(), file, line);
  size_t len = strlen(loc);
  size_t i;
  int fd;
  void* mem;
  shared_data_t *data;

  for(i = 0; i < len; i++) {
    /* Make the 'loc' ID be a flat filename */
    if(loc[i] == '/') {
      loc[i] = '_';
    }
  }
  if (!allocs) {
    allocs = xbt_dict_new_homogeneous(free);
  }
  data = xbt_dict_get_or_null(allocs, loc);
  if(!data) {
    fd = shm_open(loc, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
    if(fd < 0) {
      switch(errno) {
        case EEXIST:
          xbt_die("Please cleanup /dev/shm/%s", loc);
        default:
          xbt_die("An unhandled error occured while opening %s: %s", loc, strerror(errno));
      }
    }
    data = xbt_new(shared_data_t, 1);
    data->fd = fd;
    data->count = 1;
    data->loc = loc;
    mem = shm_map(fd, size, data);
    if(shm_unlink(loc) < 0) {
      XBT_WARN("Could not early unlink %s: %s", loc, strerror(errno));
    }
    xbt_dict_set(allocs, loc, data, NULL);
    XBT_DEBUG("Mapping %s at %p through %d", loc, mem, fd);
  } else {
    mem = shm_map(data->fd, size, data);
    data->count++;
  }
  XBT_DEBUG("Malloc %zu in %p (metadata at %p)", size, mem, data);
  return mem;
}
コード例 #20
0
ファイル: xbt_strbuff.c プロジェクト: Shurakai/SimGrid
static void mytest(const char *input, const char *patterns,
                   const char *expected)
{
  xbt_dynar_t dyn_patterns;     /* splited string */
  xbt_dict_t p;                 /* patterns */
  unsigned int cpt;
  char *str;                    /*foreach */
  xbt_strbuff_t sb;             /* what we test */

  p = xbt_dict_new_homogeneous(free);
  dyn_patterns = xbt_str_split(patterns, " ");
  xbt_dynar_foreach(dyn_patterns, cpt, str) {
    xbt_dynar_t keyvals = xbt_str_split(str, "=");
    char *key = xbt_dynar_get_as(keyvals, 0, char *);
    char *val = xbt_dynar_get_as(keyvals, 1, char *);
    xbt_str_subst(key, '_', ' ', 0);    // to put space in names without breaking the enclosing dynar_foreach
    xbt_dict_set(p, key, xbt_strdup(val), NULL);
    xbt_dynar_free(&keyvals);
  }
コード例 #21
0
ファイル: msg_host.cpp プロジェクト: luizabeltrame/simgrid
/********************************* Host **************************************/
msg_host_t __MSG_host_create(sg_host_t host) // FIXME: don't return our parameter
{
  msg_host_priv_t priv = xbt_new0(s_msg_host_priv_t, 1);

  priv->dp_objs = xbt_dict_new();
  priv->dp_enabled = 0;
  priv->dp_updated_by_deleted_tasks = 0;
  priv->is_migrating = 0;

  priv->affinity_mask_db = xbt_dict_new_homogeneous(NULL);

  priv->file_descriptor_table = xbt_dynar_new(sizeof(int), NULL);
  for (int i=1023; i>=0;i--)
    xbt_dynar_push_as(priv->file_descriptor_table, int, i);

  sg_host_msg_set(host,priv);

  return host;
}
コード例 #22
0
ActionPtr WorkstationL07Model::executeParallelTask(int workstation_nb,
                                                   void **workstation_list,
                                                 double
                                                 *computation_amount, double
                                                 *communication_amount,
                                                 double rate)
{
  WorkstationL07ActionPtr action;
  int i, j;
  unsigned int cpt;
  int nb_link = 0;
  int nb_host = 0;
  double latency = 0.0;

  if (ptask_parallel_task_link_set == NULL)
    ptask_parallel_task_link_set = xbt_dict_new_homogeneous(NULL);

  xbt_dict_reset(ptask_parallel_task_link_set);

  /* Compute the number of affected resources... */
  for (i = 0; i < workstation_nb; i++) {
    for (j = 0; j < workstation_nb; j++) {
      xbt_dynar_t route=NULL;

      if (communication_amount[i * workstation_nb + j] > 0) {
        double lat=0.0;
        unsigned int cpt;
        void *_link;
        LinkL07Ptr link;

        routing_platf->getRouteAndLatency(static_cast<WorkstationL07Ptr>(workstation_list[i])->p_netElm,
        		                          static_cast<WorkstationL07Ptr>(workstation_list[j])->p_netElm,
        		                          &route,
        		                          &lat);
        latency = MAX(latency, lat);

        xbt_dynar_foreach(route, cpt, _link) {
           link = static_cast<LinkL07Ptr>(_link);
           xbt_dict_set(ptask_parallel_task_link_set, link->getName(), link, NULL);
        }
      }
    }
コード例 #23
0
void STag_surfxml_prop(void)
{
  if(AS_TAG){ // We need a stack here to retrieve the most recently opened AS
    if (!as_current_property_set){
      xbt_assert(as_prop_nb < 1024, "Number of AS property reach the limit!!!");
      as_current_property_set = xbt_dict_new_homogeneous(xbt_free_f); // Maybe, it should raise an error
      as_name_tab[as_prop_nb] = xbt_strdup(A_surfxml_AS_id);
      as_dict_tab[as_prop_nb] = as_current_property_set;
      XBT_DEBUG("PUSH prop set %p for AS '%s'",as_dict_tab[as_prop_nb],as_name_tab[as_prop_nb]);
      as_prop_nb++;
    }
    XBT_DEBUG("add prop %s=%s into current AS property set", A_surfxml_prop_id, A_surfxml_prop_value);
    xbt_dict_set(as_current_property_set, A_surfxml_prop_id, xbt_strdup(A_surfxml_prop_value), nullptr);
  }
  else{
    if (!current_property_set)
       current_property_set = xbt_dict_new(); // Maybe, it should raise an error
    xbt_dict_set(current_property_set, A_surfxml_prop_id, xbt_strdup(A_surfxml_prop_value), xbt_free_f);
    XBT_DEBUG("add prop %s=%s into current property set", A_surfxml_prop_id, A_surfxml_prop_value);
  }
}
コード例 #24
0
/** \ingroup smpi_simulation
 * \brief Registers a running instance of a MPI program.
 *
 * FIXME : remove MSG from the loop at some point.
 * \param name the reference name of the function.
 * \param code the main mpi function (must have a int ..(int argc, char *argv[])) prototype
 * \param num_processes the size of the instance we want to deploy
 */
void SMPI_app_instance_register(const char *name, xbt_main_func_t code, int num_processes)
{
  SIMIX_function_register(name, code);

  s_smpi_mpi_instance_t* instance = (s_smpi_mpi_instance_t*)xbt_malloc(sizeof(s_smpi_mpi_instance_t));

  instance->name = name;
  instance->size = num_processes;
  instance->present_processes = 0;
  instance->index = process_count;
  instance->comm_world = MPI_COMM_NULL;
  instance->finalization_barrier=xbt_barrier_init(num_processes);

  process_count+=num_processes;

  if(smpi_instances==nullptr){
    smpi_instances = xbt_dict_new_homogeneous(xbt_free_f);
  }

  xbt_dict_set(smpi_instances, name, (void*)instance, nullptr);
  return;
}
コード例 #25
0
ファイル: smpi_bench.c プロジェクト: Shurakai/SimGrid
int smpi_shared_known_call(const char* func, const char* input) {
   char* loc = bprintf("%s:%s", func, input);
   xbt_ex_t ex;
   int known;

   if(!calls) {
      calls = xbt_dict_new_homogeneous(NULL);
   }
   TRY {
      xbt_dict_get(calls, loc); /* Succeed or throw */
      known = 1;
   }
   CATCH(ex) {
      if(ex.category == not_found_error) {
         known = 0;
         xbt_ex_free(ex);
      } else {
         RETHROW;
      }
   }
   free(loc);
   return known;
}
コード例 #26
0
ファイル: smpi_bench.c プロジェクト: Shurakai/SimGrid
void smpi_sample_1(int global, const char *file, int line, int iters, double threshold)
{
  char *loc = sample_location(global, file, line);
  local_data_t *data;

  smpi_bench_end();     /* Take time from previous, unrelated computation into account */
  if (!samples)
    samples = xbt_dict_new_homogeneous(free);

  data = xbt_dict_get_or_null(samples, loc);
  if (!data) {
    xbt_assert(threshold>0 || iters>0,
        "You should provide either a positive amount of iterations to bench, or a positive maximal stderr (or both)");
    data = (local_data_t *) xbt_new(local_data_t, 1);
    data->count = 0;
    data->sum = 0.0;
    data->sum_pow2 = 0.0;
    data->iters = iters;
    data->threshold = threshold;
    data->benching = 1; // If we have no data, we need at least one
    data->mean = 0;
    xbt_dict_set(samples, loc, data, NULL);
    XBT_DEBUG("XXXXX First time ever on benched nest %s.",loc);
  } else {
    if (data->iters != iters || data->threshold != threshold) {
      XBT_ERROR("Asked to bench block %s with different settings %d, %f is not %d, %f. How did you manage to give two numbers at the same line??",
          loc, data->iters, data->threshold, iters,threshold);
      THROW_IMPOSSIBLE;
    }

    // if we already have some data, check whether sample_2 should get one more bench or whether it should emulate the computation instead
    data->benching = !sample_enough_benchs(data);
    XBT_DEBUG("XXXX Re-entering the benched nest %s. %s",loc, (data->benching?"more benching needed":"we have enough data, skip computes"));
  }
  free(loc);
}
コード例 #27
0
xbt_dict_t Storage::parseContent(char *filename)
{
  m_usedSize = 0;
  if ((!filename) || (strcmp(filename, "") == 0))
    return NULL;

  xbt_dict_t parse_content = xbt_dict_new_homogeneous(xbt_free_f);
  FILE *file = NULL;

  file = surf_fopen(filename, "r");
  if (file == NULL)
    xbt_die("Cannot open file '%s' (path=%s)", filename,
            xbt_str_join(surf_path, ":"));

  char *line = NULL;
  size_t len = 0;
  ssize_t read;
  char path[1024];
  sg_size_t size;

  while ((read = xbt_getline(&line, &len, file)) != -1) {
    if (read){
      if(sscanf(line,"%s %llu", path, &size) == 2) {
        m_usedSize += size;
        sg_size_t *psize = xbt_new(sg_size_t, 1);
        *psize = size;
        xbt_dict_set(parse_content,path,psize,NULL);
      } else {
        xbt_die("Be sure of passing a good format for content file.\n");
      }
    }
  }
  free(line);
  fclose(file);
  return parse_content;
}
コード例 #28
0
ファイル: instr_smpi.c プロジェクト: dhascome/simgrid
void TRACE_smpi_alloc()
{
  keys = xbt_dict_new_homogeneous(xbt_dynar_free_voidp);
  process_category = xbt_dict_new_homogeneous(xbt_free);
}
コード例 #29
0
ファイル: surfxml_parseplatf.cpp プロジェクト: R7R8/simgrid
/* This function acts as a main in the parsing area. */
void parse_platform_file(const char *file)
{
#if HAVE_LUA
  int is_lua = (file != NULL && strlen(file) > 3 && file[strlen(file)-3] == 'l' && file[strlen(file)-2] == 'u'
        && file[strlen(file)-1] == 'a');
#endif

  sg_platf_init();

#if HAVE_LUA
  /* Check if file extension is "lua". If so, we will use
   * the lua bindings to parse the platform file (since it is
   * written in lua). If not, we will use the (old?) XML parser
   */
  if (is_lua) {
    lua_State* L = luaL_newstate();
    luaL_openlibs(L);

    luaL_loadfile(L, file); // This loads the file without executing it.

    /* Run the script */
    if (lua_pcall(L, 0, 0, 0)) {
        XBT_ERROR("FATAL ERROR:\n  %s: %s\n\n", "Lua call failed. Errormessage:", lua_tostring(L, -1));
        xbt_die("Lua call failed. See Log");
    }
  }
  else
#endif
  { // Use XML parser

    int parse_status;

    /* init the flex parser */
    surfxml_buffer_stack_stack_ptr = 1;
    surfxml_buffer_stack_stack[0] = 0;
    after_config_done = 0;
    surf_parse_open(file);

    traces_set_list = xbt_dict_new_homogeneous(NULL);
    trace_connect_list_host_avail = xbt_dict_new_homogeneous(free);
    trace_connect_list_host_speed = xbt_dict_new_homogeneous(free);
    trace_connect_list_link_avail = xbt_dict_new_homogeneous(free);
    trace_connect_list_link_bw = xbt_dict_new_homogeneous(free);
    trace_connect_list_link_lat = xbt_dict_new_homogeneous(free);

    /* Init my data */
    if (!surfxml_bufferstack_stack)
      surfxml_bufferstack_stack = xbt_dynar_new(sizeof(char *), NULL);

    /* Do the actual parsing */
    parse_status = surf_parse();

    /* connect all traces relative to hosts */
    xbt_dict_cursor_t cursor = NULL;
    char *trace_name, *elm;

    xbt_dict_foreach(trace_connect_list_host_avail, cursor, trace_name, elm) {
      tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
      xbt_assert(trace, "Trace %s undefined", trace_name);

      simgrid::s4u::Host *host = sg_host_by_name(elm);
      xbt_assert(host, "Host %s undefined", elm);
      simgrid::surf::Cpu *cpu = host->pimpl_cpu;

      cpu->setStateTrace(trace);
    }
    xbt_dict_foreach(trace_connect_list_host_speed, cursor, trace_name, elm) {
      tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
      xbt_assert(trace, "Trace %s undefined", trace_name);

      simgrid::s4u::Host *host = sg_host_by_name(elm);
      xbt_assert(host, "Host %s undefined", elm);
      simgrid::surf::Cpu *cpu = host->pimpl_cpu;

      cpu->setSpeedTrace(trace);
    }
コード例 #30
0
void TRACE_surf_resource_utilization_alloc()
{
  platform_variables = xbt_dict_new_homogeneous(NULL);
}