do not store the requests on the process's stack nor in the big vector

Instead, they are directly in the s_smx_process_t structure.

There is no stack when going in replay contextes (still to be done)
And the vector may be realloced when creating processes, so saving
pointers to its content is not stable.

git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@9082 48e7efb5-ca39-0410-a469-dd3cf9ba447f

diff --git a/src/simix/process_private.h b/src/simix/process_private.h
index 54f4196..b7fc26b 100644 (file)
--- a/src/simix/process_private.h
+++ b/src/simix/process_private.h
@@ -29,7 +29,7 @@ typedef struct s_smx_process {
   int suspended:1;
   smx_action_t waiting_action;
   xbt_dict_t properties;
   int suspended:1;
   smx_action_t waiting_action;
   xbt_dict_t properties;

-  smx_req_t request;
+  s_smx_req_t request;

   void *data;                   /* kept for compatibility, it should be replaced with moddata */
 
 } s_smx_process_t;
   void *data;                   /* kept for compatibility, it should be replaced with moddata */
 
 } s_smx_process_t;

diff --git a/src/simix/smurf_private.h b/src/simix/smurf_private.h
index 4f0a7ab..f150f85 100644 (file)
--- a/src/simix/smurf_private.h
+++ b/src/simix/smurf_private.h
@@ -9,6 +9,7 @@
 
 /********************************* Requests ***********************************/
 typedef enum {
 
 /********************************* Requests ***********************************/
 typedef enum {

+  REQ_NO_REQ, /* Used when there is no ongoing request here */

   REQ_HOST_GET_BY_NAME,
   REQ_HOST_GET_NAME,
   REQ_HOST_GET_PROPERTIES,
   REQ_HOST_GET_BY_NAME,
   REQ_HOST_GET_NAME,
   REQ_HOST_GET_PROPERTIES,


@@ -470,13 +471,14 @@ typedef struct s_smx_req {
 
 void SIMIX_request_init(void);
 void SIMIX_request_destroy(void);
 
 void SIMIX_request_init(void);
 void SIMIX_request_destroy(void);

-void SIMIX_request_push(smx_req_t);
+void SIMIX_request_push(void);

 smx_req_t SIMIX_request_pop(void);
 void SIMIX_request_answer(smx_req_t);
 void SIMIX_request_pre(smx_req_t);
 void SIMIX_request_post(smx_action_t);
 int SIMIX_request_is_visible(smx_req_t req);
 int SIMIX_request_is_enabled(smx_req_t req);
 smx_req_t SIMIX_request_pop(void);
 void SIMIX_request_answer(smx_req_t);
 void SIMIX_request_pre(smx_req_t);
 void SIMIX_request_post(smx_action_t);
 int SIMIX_request_is_visible(smx_req_t req);
 int SIMIX_request_is_enabled(smx_req_t req);

+XBT_INLINE smx_req_t SIMIX_req_mine(void);

 
 #endif
 
 
 #endif
 

diff --git a/src/simix/smx_process.c b/src/simix/smx_process.c
index 01a6d29..d3353c2 100644 (file)
--- a/src/simix/smx_process.c
+++ b/src/simix/smx_process.c
@@ -81,6 +81,7 @@ void SIMIX_create_maestro_process()
   maestro->running_ctx = xbt_new(xbt_running_ctx_t, 1);
   XBT_RUNNING_CTX_INITIALIZE(maestro->running_ctx);
   maestro->context = SIMIX_context_new(NULL, 0, NULL, NULL, maestro);
   maestro->running_ctx = xbt_new(xbt_running_ctx_t, 1);
   XBT_RUNNING_CTX_INITIALIZE(maestro->running_ctx);
   maestro->context = SIMIX_context_new(NULL, 0, NULL, NULL, maestro);

+  maestro->request.issuer = maestro;

 
   simix_global->maestro_process = maestro;
   return;
 
   simix_global->maestro_process = maestro;
   return;


@@ -213,7 +214,7 @@ void SIMIX_process_kill(smx_process_t process, smx_process_t killer) {
        break;
 
       case SIMIX_ACTION_SYNCHRO:
        break;
 
       case SIMIX_ACTION_SYNCHRO:

-       SIMIX_synchro_stop_waiting(process, process->request);
+       SIMIX_synchro_stop_waiting(process, &process->request);

        SIMIX_synchro_destroy(process->waiting_action);
        break;
 
        SIMIX_synchro_destroy(process->waiting_action);
        break;
 


@@ -402,7 +403,7 @@ int SIMIX_process_is_suspended(smx_process_t process)
 
 int SIMIX_process_is_enabled(smx_process_t process)
 {
 
 int SIMIX_process_is_enabled(smx_process_t process)
 {

-  if (process->request && SIMIX_request_is_enabled(process->request))
+  if (process->request.call != REQ_NO_REQ && SIMIX_request_is_enabled(&process->request))

     return TRUE;
 
   return FALSE;
     return TRUE;
 
   return FALSE;

diff --git a/src/simix/smx_smurf.c b/src/simix/smx_smurf.c
index e358404..65010aa 100644 (file)
--- a/src/simix/smx_smurf.c
+++ b/src/simix/smx_smurf.c
@@ -5,57 +5,57 @@
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_smurf, simix,
                                 "Logging specific to SIMIX (SMURF)");
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_smurf, simix,
                                 "Logging specific to SIMIX (SMURF)");
 

-/* Array storing all requests to be handled in this scheduling round */
-static smx_req_t* req_vector=NULL;
-/* Positions of the previous array with non-null data */
-static xbt_heap_t req_positions;
+/* Requests to handle at the end of this round of scheduling user processes */
+static xbt_heap_t req_todo;

 /* to protect the write actions in the heap */
 static xbt_os_mutex_t sync_req_positions;
 
 void SIMIX_request_init(void)
 {
 /* to protect the write actions in the heap */
 static xbt_os_mutex_t sync_req_positions;
 
 void SIMIX_request_init(void)
 {

-  req_vector = xbt_new0(smx_req_t,1);/* enough room for maestro's requests */
-  req_positions = xbt_heap_new(5,NULL);
+  req_todo = xbt_heap_new(5,NULL);

   sync_req_positions = xbt_os_mutex_init();
 }
 
 void SIMIX_request_destroy(void)
 {
   sync_req_positions = xbt_os_mutex_init();
 }
 
 void SIMIX_request_destroy(void)
 {

-  free(req_vector);
-  req_vector = NULL;
-  xbt_heap_free(req_positions);
+  xbt_heap_free(req_todo);

   xbt_os_mutex_destroy(sync_req_positions);
 }
 
   xbt_os_mutex_destroy(sync_req_positions);
 }
 

-void SIMIX_request_push(smx_req_t req)
+/* FIXME: we may want to save the initialization of issuer... */
+XBT_INLINE smx_req_t SIMIX_req_mine() {
+  smx_process_t issuer = SIMIX_process_self();
+  return &issuer->request;
+}
+
+void SIMIX_request_push()

 {
 {

-  req->issuer = SIMIX_process_self();
-  if (req->issuer != simix_global->maestro_process){
-    req_vector[req->issuer->pid] = req;
-    req->issuer->request = req;
+  smx_process_t issuer = SIMIX_process_self();
+  if (issuer != simix_global->maestro_process){
+    issuer->request.issuer = issuer;

 
     if (_surf_parallel_contexts)
       xbt_os_mutex_acquire(sync_req_positions);
 
     if (_surf_parallel_contexts)
       xbt_os_mutex_acquire(sync_req_positions);

-    xbt_heap_push(req_positions,req,req->issuer->pid);
+    xbt_heap_push(req_todo,&issuer->request,issuer->pid);

     if (_surf_parallel_contexts)
       xbt_os_mutex_release(sync_req_positions);
 
     if (_surf_parallel_contexts)
       xbt_os_mutex_release(sync_req_positions);
 

-    DEBUG2("Yield process '%s' on request of type %d", req->issuer->name, req->call);
+    DEBUG2("Yield process '%s' on request of type %d", issuer->name, issuer->request.call);

     SIMIX_process_yield();
   } else {
     SIMIX_process_yield();
   } else {

-    SIMIX_request_pre(req);
+    SIMIX_request_pre(&issuer->request);

   }
 }
 
 smx_req_t SIMIX_request_pop(void)
 {
   }
 }
 
 smx_req_t SIMIX_request_pop(void)
 {

-  return xbt_heap_pop(req_positions);
+  return xbt_heap_pop(req_todo);

 }
 
 void SIMIX_request_answer(smx_req_t req)
 {
   if (req->issuer != simix_global->maestro_process){
 }
 
 void SIMIX_request_answer(smx_req_t req)
 {
   if (req->issuer != simix_global->maestro_process){

-    req->issuer->request = NULL;    
+    req->issuer->request.call = REQ_NO_REQ;

     xbt_swag_insert(req->issuer, simix_global->process_to_run);
   }
 }
     xbt_swag_insert(req->issuer, simix_global->process_to_run);
   }
 }


@@ -102,6 +102,9 @@ int SIMIX_request_is_enabled(smx_req_t req)
 void SIMIX_request_pre(smx_req_t req)
 {
   switch (req->call) {
 void SIMIX_request_pre(smx_req_t req)
 {
   switch (req->call) {

+  case REQ_NO_REQ:
+    xbt_die("Asked to do the noop syscall");
+    break;

 
     case REQ_HOST_GET_BY_NAME:
       req->host_get_by_name.result =
 
     case REQ_HOST_GET_BY_NAME:
       req->host_get_by_name.result =


@@ -202,7 +205,6 @@ void SIMIX_request_pre(smx_req_t req)
       break;
 
     case REQ_PROCESS_CREATE:
       break;
 
     case REQ_PROCESS_CREATE:

-      req_vector = xbt_realloc(req_vector,sizeof(smx_req_t)*(SIMIX_process_get_maxpid()+2));

       req->process_create.result = SIMIX_process_create(
          req->process_create.name,
          req->process_create.code,
       req->process_create.result = SIMIX_process_create(
          req->process_create.name,
          req->process_create.code,

diff --git a/src/simix/smx_synchro.c b/src/simix/smx_synchro.c
index 7f6fae4..82dff9e 100644 (file)
--- a/src/simix/smx_synchro.c
+++ b/src/simix/smx_synchro.c
@@ -201,7 +201,7 @@ void SIMIX_mutex_unlock(smx_mutex_t mutex, smx_process_t issuer)
     SIMIX_synchro_destroy(p->waiting_action);
     p->waiting_action = NULL;
     mutex->owner = p;
     SIMIX_synchro_destroy(p->waiting_action);
     p->waiting_action = NULL;
     mutex->owner = p;

-    SIMIX_request_answer(p->request);
+    SIMIX_request_answer(&p->request);

   } else {
     /* nobody to wake up */
     mutex->locked = 0;
   } else {
     /* nobody to wake up */
     mutex->locked = 0;


@@ -313,7 +313,7 @@ void SIMIX_cond_signal(smx_cond_t cond)
     proc->waiting_action = NULL;
 
     /* Now transform the cond wait request into a mutex lock one */
     proc->waiting_action = NULL;
 
     /* Now transform the cond wait request into a mutex lock one */

-    req = proc->request;
+    req = &proc->request;

     if(req->call == REQ_COND_WAIT)
       mutex = req->cond_wait.mutex;
     else
     if(req->call == REQ_COND_WAIT)
       mutex = req->cond_wait.mutex;
     else


@@ -401,7 +401,7 @@ void SIMIX_sem_release(smx_sem_t sem)
     proc = xbt_swag_extract(sem->sleeping);
     SIMIX_synchro_destroy(proc->waiting_action);
     proc->waiting_action = NULL;
     proc = xbt_swag_extract(sem->sleeping);
     SIMIX_synchro_destroy(proc->waiting_action);
     proc->waiting_action = NULL;

-    SIMIX_request_answer(proc->request);
+    SIMIX_request_answer(&proc->request);

   } else if (sem->value < SMX_SEM_NOLIMIT) {
     sem->value++;
   }
   } else if (sem->value < SMX_SEM_NOLIMIT) {
     sem->value++;
   }

diff --git a/src/simix/smx_user.c b/src/simix/smx_user.c
index b42fc6b..3d1f880 100644 (file)
--- a/src/simix/smx_user.c
+++ b/src/simix/smx_user.c
@@ -9,12 +9,12 @@ XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix);
  */
 smx_host_t SIMIX_req_host_get_by_name(const char *name)
 {
  */
 smx_host_t SIMIX_req_host_get_by_name(const char *name)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_GET_BY_NAME;
-  req.host_get_by_name.name = name;
-  SIMIX_request_push(&req);
-  return req.host_get_by_name.result;
+  req->call = REQ_HOST_GET_BY_NAME;
+  req->host_get_by_name.name = name;
+  SIMIX_request_push();
+  return req->host_get_by_name.result;

 }
 
 /**
 }
 
 /**


@@ -25,12 +25,12 @@ smx_host_t SIMIX_req_host_get_by_name(const char *name)
  */
 const char* SIMIX_req_host_get_name(smx_host_t host)
 {
  */
 const char* SIMIX_req_host_get_name(smx_host_t host)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_GET_NAME;
-  req.host_get_name.host = host;
-  SIMIX_request_push(&req);
-  return req.host_get_name.result;
+  req->call = REQ_HOST_GET_NAME;
+  req->host_get_name.host = host;
+  SIMIX_request_push();
+  return req->host_get_name.result;

 }
 
 /**
 }
 
 /**


@@ -41,12 +41,12 @@ const char* SIMIX_req_host_get_name(smx_host_t host)
  */
 xbt_dict_t SIMIX_req_host_get_properties(smx_host_t host)
 {
  */
 xbt_dict_t SIMIX_req_host_get_properties(smx_host_t host)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_GET_PROPERTIES;
-  req.host_get_properties.host = host;
-  SIMIX_request_push(&req);
-  return req.host_get_properties.result;
+  req->call = REQ_HOST_GET_PROPERTIES;
+  req->host_get_properties.host = host;
+  SIMIX_request_push();
+  return req->host_get_properties.result;

 }
 
 /**
 }
 
 /**


@@ -58,12 +58,12 @@ xbt_dict_t SIMIX_req_host_get_properties(smx_host_t host)
  */
 double SIMIX_req_host_get_speed(smx_host_t host)
 {
  */
 double SIMIX_req_host_get_speed(smx_host_t host)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_GET_SPEED;
-  req.host_get_speed.host = host;
-  SIMIX_request_push(&req);
-  return req.host_get_speed.result;
+  req->call = REQ_HOST_GET_SPEED;
+  req->host_get_speed.host = host;
+  SIMIX_request_push();
+  return req->host_get_speed.result;

 }
 
 /**
 }
 
 /**


@@ -73,12 +73,12 @@ double SIMIX_req_host_get_speed(smx_host_t host)
  */
 double SIMIX_req_host_get_available_speed(smx_host_t host)
 {
  */
 double SIMIX_req_host_get_available_speed(smx_host_t host)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_GET_AVAILABLE_SPEED;
-  req.host_get_available_speed.host = host;
-  SIMIX_request_push(&req);
-  return req.host_get_available_speed.result;
+  req->call = REQ_HOST_GET_AVAILABLE_SPEED;
+  req->host_get_available_speed.host = host;
+  SIMIX_request_push();
+  return req->host_get_available_speed.result;

 }
 
 /**
 }
 
 /**


@@ -90,12 +90,12 @@ double SIMIX_req_host_get_available_speed(smx_host_t host)
  */
 int SIMIX_req_host_get_state(smx_host_t host)
 {
  */
 int SIMIX_req_host_get_state(smx_host_t host)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_GET_STATE;
-  req.host_get_state.host = host;
-  SIMIX_request_push(&req);
-  return req.host_get_state.result;
+  req->call = REQ_HOST_GET_STATE;
+  req->host_get_state.host = host;
+  SIMIX_request_push();
+  return req->host_get_state.result;

 }
 
 /**
 }
 
 /**


@@ -106,12 +106,12 @@ int SIMIX_req_host_get_state(smx_host_t host)
  */
 void* SIMIX_req_host_get_data(smx_host_t host)
 {
  */
 void* SIMIX_req_host_get_data(smx_host_t host)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_GET_DATA;
-  req.host_get_data.host = host;
-  SIMIX_request_push(&req);
-  return req.host_get_data.result;
+  req->call = REQ_HOST_GET_DATA;
+  req->host_get_data.host = host;
+  SIMIX_request_push();
+  return req->host_get_data.result;

 }
 
 /**
 }
 
 /**


@@ -123,12 +123,12 @@ void* SIMIX_req_host_get_data(smx_host_t host)
  */
 void SIMIX_req_host_set_data(smx_host_t host, void *data)
 {
  */
 void SIMIX_req_host_set_data(smx_host_t host, void *data)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_SET_DATA;
-  req.host_set_data.host = host;
-  req.host_set_data.data = data;
-  SIMIX_request_push(&req);
+  req->call = REQ_HOST_SET_DATA;
+  req->host_set_data.host = host;
+  req->host_set_data.data = data;
+  SIMIX_request_push();

 }
 
 /** \brief Creates an action that executes some computation of an host.
 }
 
 /** \brief Creates an action that executes some computation of an host.


@@ -144,14 +144,14 @@ void SIMIX_req_host_set_data(smx_host_t host, void *data)
 smx_action_t SIMIX_req_host_execute(const char *name, smx_host_t host,
                                 double computation_amount)
 {
 smx_action_t SIMIX_req_host_execute(const char *name, smx_host_t host,
                                 double computation_amount)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_EXECUTE;
-  req.host_execute.name = name;
-  req.host_execute.host = host;
-  req.host_execute.computation_amount = computation_amount;
-  SIMIX_request_push(&req);
-  return req.host_execute.result;
+  req->call = REQ_HOST_EXECUTE;
+  req->host_execute.name = name;
+  req->host_execute.host = host;
+  req->host_execute.computation_amount = computation_amount;
+  SIMIX_request_push();
+  return req->host_execute.result;

 }
 
 /** \brief Creates an action that may involve parallel computation on
 }
 
 /** \brief Creates an action that may involve parallel computation on


@@ -175,18 +175,18 @@ smx_action_t SIMIX_req_host_parallel_execute(const char *name,
                                          double amount,
                                          double rate)
 {
                                          double amount,
                                          double rate)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_PARALLEL_EXECUTE;
-  req.host_parallel_execute.name = name;
-  req.host_parallel_execute.host_nb = host_nb;
-  req.host_parallel_execute.host_list = host_list;
-  req.host_parallel_execute.computation_amount = computation_amount;
-  req.host_parallel_execute.communication_amount = communication_amount;
-  req.host_parallel_execute.amount = amount;
-  req.host_parallel_execute.rate = rate;
-  SIMIX_request_push(&req);
-  return req.host_parallel_execute.result;
+  req->call = REQ_HOST_PARALLEL_EXECUTE;
+  req->host_parallel_execute.name = name;
+  req->host_parallel_execute.host_nb = host_nb;
+  req->host_parallel_execute.host_list = host_list;
+  req->host_parallel_execute.computation_amount = computation_amount;
+  req->host_parallel_execute.communication_amount = communication_amount;
+  req->host_parallel_execute.amount = amount;
+  req->host_parallel_execute.rate = rate;
+  SIMIX_request_push();
+  return req->host_parallel_execute.result;

 }
 
 /**
 }
 
 /**


@@ -197,11 +197,11 @@ smx_action_t SIMIX_req_host_parallel_execute(const char *name,
  */
 void SIMIX_req_host_execution_destroy(smx_action_t execution)
 {
  */
 void SIMIX_req_host_execution_destroy(smx_action_t execution)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_EXECUTION_DESTROY;
-  req.host_execution_destroy.execution = execution;
-  SIMIX_request_push(&req);
+  req->call = REQ_HOST_EXECUTION_DESTROY;
+  req->host_execution_destroy.execution = execution;
+  SIMIX_request_push();

 }
 
 /**
 }
 
 /**


@@ -212,11 +212,11 @@ void SIMIX_req_host_execution_destroy(smx_action_t execution)
  */
 void SIMIX_req_host_execution_cancel(smx_action_t execution)
 {
  */
 void SIMIX_req_host_execution_cancel(smx_action_t execution)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_EXECUTION_CANCEL;
-  req.host_execution_cancel.execution = execution;
-  SIMIX_request_push(&req);
+  req->call = REQ_HOST_EXECUTION_CANCEL;
+  req->host_execution_cancel.execution = execution;
+  SIMIX_request_push();

 }
 
 /**
 }
 
 /**


@@ -227,12 +227,12 @@ void SIMIX_req_host_execution_cancel(smx_action_t execution)
  */
 double SIMIX_req_host_execution_get_remains(smx_action_t execution)
 {
  */
 double SIMIX_req_host_execution_get_remains(smx_action_t execution)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_EXECUTION_GET_REMAINS;
-  req.host_execution_get_remains.execution = execution;
-  SIMIX_request_push(&req);
-  return req.host_execution_get_remains.result;
+  req->call = REQ_HOST_EXECUTION_GET_REMAINS;
+  req->host_execution_get_remains.execution = execution;
+  SIMIX_request_push();
+  return req->host_execution_get_remains.result;

 }
 
 /**
 }
 
 /**


@@ -243,12 +243,12 @@ double SIMIX_req_host_execution_get_remains(smx_action_t execution)
  */
 e_smx_state_t SIMIX_req_host_execution_get_state(smx_action_t execution)
 {
  */
 e_smx_state_t SIMIX_req_host_execution_get_state(smx_action_t execution)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_EXECUTION_GET_STATE;
-  req.host_execution_get_state.execution = execution;
-  SIMIX_request_push(&req);
-  return req.host_execution_get_state.result;
+  req->call = REQ_HOST_EXECUTION_GET_STATE;
+  req->host_execution_get_state.execution = execution;
+  SIMIX_request_push();
+  return req->host_execution_get_state.result;

 }
 
 /**
 }
 
 /**


@@ -260,12 +260,12 @@ e_smx_state_t SIMIX_req_host_execution_get_state(smx_action_t execution)
  */
 void SIMIX_req_host_execution_set_priority(smx_action_t execution, double priority)
 {
  */
 void SIMIX_req_host_execution_set_priority(smx_action_t execution, double priority)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_EXECUTION_SET_PRIORITY;
-  req.host_execution_set_priority.execution = execution;
-  req.host_execution_set_priority.priority = priority;
-  SIMIX_request_push(&req);
+  req->call = REQ_HOST_EXECUTION_SET_PRIORITY;
+  req->host_execution_set_priority.execution = execution;
+  req->host_execution_set_priority.priority = priority;
+  SIMIX_request_push();

 }
 
 /**
 }
 
 /**


@@ -275,11 +275,11 @@ void SIMIX_req_host_execution_set_priority(smx_action_t execution, double priori
  */
 void SIMIX_req_host_execution_wait(smx_action_t execution)
 {
  */
 void SIMIX_req_host_execution_wait(smx_action_t execution)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_HOST_EXECUTION_WAIT;
-  req.host_execution_wait.execution = execution;
-  SIMIX_request_push(&req);
+  req->call = REQ_HOST_EXECUTION_WAIT;
+  req->host_execution_wait.execution = execution;
+  SIMIX_request_push();

 }
 
 /**
 }
 
 /**


@@ -304,18 +304,18 @@ smx_process_t SIMIX_req_process_create(const char *name,
                                    int argc, char **argv,
                                    xbt_dict_t properties)
 {
                                    int argc, char **argv,
                                    xbt_dict_t properties)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_PROCESS_CREATE;
-  req.process_create.name = name;
-  req.process_create.code = code;
-  req.process_create.data = data;
-  req.process_create.hostname = hostname;
-  req.process_create.argc = argc;
-  req.process_create.argv = argv;
-  req.process_create.properties = properties;
-  SIMIX_request_push(&req);
-  return req.process_create.result;
+  req->call = REQ_PROCESS_CREATE;
+  req->process_create.name = name;
+  req->process_create.code = code;
+  req->process_create.data = data;
+  req->process_create.hostname = hostname;
+  req->process_create.argc = argc;
+  req->process_create.argv = argv;
+  req->process_create.properties = properties;
+  SIMIX_request_push();
+  return req->process_create.result;

 }
 
 /** \brief Kills a SIMIX process.
 }
 
 /** \brief Kills a SIMIX process.


@@ -326,11 +326,11 @@ smx_process_t SIMIX_req_process_create(const char *name,
  */
 void SIMIX_req_process_kill(smx_process_t process)
 {
  */
 void SIMIX_req_process_kill(smx_process_t process)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_PROCESS_KILL;
-  req.process_kill.process = process;
-  SIMIX_request_push(&req);
+  req->call = REQ_PROCESS_KILL;
+  req->process_kill.process = process;
+  SIMIX_request_push();

 }
 
 /**
 }
 
 /**


@@ -344,13 +344,13 @@ void SIMIX_req_process_kill(smx_process_t process)
  */
 void SIMIX_req_process_change_host(smx_process_t process, const char *source, const char *dest)
 {
  */
 void SIMIX_req_process_change_host(smx_process_t process, const char *source, const char *dest)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_PROCESS_CHANGE_HOST;
-  req.process_change_host.process = process;
-  req.process_change_host.source = source;
-  req.process_change_host.dest = dest;
-  SIMIX_request_push(&req);
+  req->call = REQ_PROCESS_CHANGE_HOST;
+  req->process_change_host.process = process;
+  req->process_change_host.source = source;
+  req->process_change_host.dest = dest;
+  SIMIX_request_push();

 }
 
 /**
 }
 
 /**


@@ -363,11 +363,11 @@ void SIMIX_req_process_change_host(smx_process_t process, const char *source, co
  */
 void SIMIX_req_process_suspend(smx_process_t process)
 {
  */
 void SIMIX_req_process_suspend(smx_process_t process)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_PROCESS_SUSPEND;
-  req.process_suspend.process = process;
-  SIMIX_request_push(&req);
+  req->call = REQ_PROCESS_SUSPEND;
+  req->process_suspend.process = process;
+  SIMIX_request_push();

 }
 
 /**
 }
 
 /**


@@ -380,11 +380,11 @@ void SIMIX_req_process_suspend(smx_process_t process)
  */
 void SIMIX_req_process_resume(smx_process_t process)
 {
  */
 void SIMIX_req_process_resume(smx_process_t process)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_PROCESS_RESUME;
-  req.process_resume.process = process;
-  SIMIX_request_push(&req);
+  req->call = REQ_PROCESS_RESUME;
+  req->process_resume.process = process;
+  SIMIX_request_push();

 }
 
 /**
 }
 
 /**


@@ -394,11 +394,11 @@ void SIMIX_req_process_resume(smx_process_t process)
  */
 int SIMIX_req_process_count(void)
 {
  */
 int SIMIX_req_process_count(void)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_PROCESS_COUNT;
-  SIMIX_request_push(&req);
-  return req.process_count.result;
+  req->call = REQ_PROCESS_COUNT;
+  SIMIX_request_push();
+  return req->process_count.result;

 }
 
 /**
 }
 
 /**


@@ -410,12 +410,12 @@ int SIMIX_req_process_count(void)
  */
 void* SIMIX_req_process_get_data(smx_process_t process)
 {
  */
 void* SIMIX_req_process_get_data(smx_process_t process)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_PROCESS_GET_DATA;
-  req.process_get_data.process = process;
-  SIMIX_request_push(&req);
-  return req.process_get_data.result;
+  req->call = REQ_PROCESS_GET_DATA;
+  req->process_get_data.process = process;
+  SIMIX_request_push();
+  return req->process_get_data.result;

 }
 
 /**
 }
 
 /**


@@ -427,12 +427,12 @@ void* SIMIX_req_process_get_data(smx_process_t process)
  */
 void SIMIX_req_process_set_data(smx_process_t process, void *data)
 {
  */
 void SIMIX_req_process_set_data(smx_process_t process, void *data)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_PROCESS_SET_DATA;
-  req.process_set_data.process = process;
-  req.process_set_data.data = data;
-  SIMIX_request_push(&req);
+  req->call = REQ_PROCESS_SET_DATA;
+  req->process_set_data.process = process;
+  req->process_set_data.data = data;
+  SIMIX_request_push();

 }
 
 /**
 }
 
 /**


@@ -444,12 +444,12 @@ void SIMIX_req_process_set_data(smx_process_t process, void *data)
  */
 smx_host_t SIMIX_req_process_get_host(smx_process_t process)
 {
  */
 smx_host_t SIMIX_req_process_get_host(smx_process_t process)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_PROCESS_GET_HOST;
-  req.process_get_host.process = process;
-  SIMIX_request_push(&req);
-  return req.process_get_host.result;
+  req->call = REQ_PROCESS_GET_HOST;
+  req->process_get_host.process = process;
+  SIMIX_request_push();
+  return req->process_get_host.result;

 }
 
 /**
 }
 
 /**


@@ -461,12 +461,12 @@ smx_host_t SIMIX_req_process_get_host(smx_process_t process)
  */
 const char* SIMIX_req_process_get_name(smx_process_t process)
 {
  */
 const char* SIMIX_req_process_get_name(smx_process_t process)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_PROCESS_GET_NAME;
-  req.process_get_name.process = process;
-  SIMIX_request_push(&req);
-  return req.process_get_name.result;
+  req->call = REQ_PROCESS_GET_NAME;
+  req->process_get_name.process = process;
+  SIMIX_request_push();
+  return req->process_get_name.result;

 }
 
 /**
 }
 
 /**


@@ -478,12 +478,12 @@ const char* SIMIX_req_process_get_name(smx_process_t process)
  */
 int SIMIX_req_process_is_suspended(smx_process_t process)
 {
  */
 int SIMIX_req_process_is_suspended(smx_process_t process)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_PROCESS_IS_SUSPENDED;
-  req.process_is_suspended.process = process;
-  SIMIX_request_push(&req);
-  return req.process_is_suspended.result;
+  req->call = REQ_PROCESS_IS_SUSPENDED;
+  req->process_is_suspended.process = process;
+  SIMIX_request_push();
+  return req->process_is_suspended.result;

 }
 
 /** \ingroup m_process_management
 }
 
 /** \ingroup m_process_management


@@ -493,12 +493,12 @@ int SIMIX_req_process_is_suspended(smx_process_t process)
  */
 xbt_dict_t SIMIX_req_process_get_properties(smx_process_t process)
 {
  */
 xbt_dict_t SIMIX_req_process_get_properties(smx_process_t process)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_PROCESS_GET_PROPERTIES;
-  req.process_get_properties.process = process;
-  SIMIX_request_push(&req);
-  return req.process_get_properties.result;
+  req->call = REQ_PROCESS_GET_PROPERTIES;
+  req->process_get_properties.process = process;
+  SIMIX_request_push();
+  return req->process_get_properties.result;

 }
 
 /** \brief Creates a new sleep SIMIX action.
 }
 
 /** \brief Creates a new sleep SIMIX action.


@@ -512,12 +512,12 @@ xbt_dict_t SIMIX_req_process_get_properties(smx_process_t process)
  */
 e_smx_state_t SIMIX_req_process_sleep(double duration)
 {
  */
 e_smx_state_t SIMIX_req_process_sleep(double duration)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_PROCESS_SLEEP;
-  req.process_sleep.duration = duration;
-  SIMIX_request_push(&req);
-  return req.process_sleep.result;
+  req->call = REQ_PROCESS_SLEEP;
+  req->process_sleep.duration = duration;
+  SIMIX_request_push();
+  return req->process_sleep.result;

 }
 
 /**
 }
 
 /**


@@ -527,13 +527,13 @@ e_smx_state_t SIMIX_req_process_sleep(double duration)
  */
 smx_rdv_t SIMIX_req_rdv_create(const char *name)
 {
  */
 smx_rdv_t SIMIX_req_rdv_create(const char *name)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_RDV_CREATE;
-  req.rdv_create.name = name;
+  req->call = REQ_RDV_CREATE;
+  req->rdv_create.name = name;

 
 

-  SIMIX_request_push(&req);
-  return req.rdv_create.result;
+  SIMIX_request_push();
+  return req->rdv_create.result;

 }
 
 
 }
 
 


@@ -543,22 +543,22 @@ smx_rdv_t SIMIX_req_rdv_create(const char *name)
  */
 void SIMIX_req_rdv_destroy(smx_rdv_t rdv)
 {
  */
 void SIMIX_req_rdv_destroy(smx_rdv_t rdv)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_RDV_DESTROY; 
-  req.rdv_destroy.rdv = rdv;
+  req->call = REQ_RDV_DESTROY;
+  req->rdv_destroy.rdv = rdv;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 smx_rdv_t SIMIX_req_rdv_get_by_name(const char *name)
 {
 }
 
 smx_rdv_t SIMIX_req_rdv_get_by_name(const char *name)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_RDV_GEY_BY_NAME;
-  req.rdv_get_by_name.name = name;
-  SIMIX_request_push(&req);
-  return req.rdv_get_by_name.result;
+  req->call = REQ_RDV_GEY_BY_NAME;
+  req->rdv_get_by_name.name = name;
+  SIMIX_request_push();
+  return req->rdv_get_by_name.result;

 }
 
 /**
 }
 
 /**


@@ -570,14 +570,14 @@ smx_rdv_t SIMIX_req_rdv_get_by_name(const char *name)
  */
 int SIMIX_req_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host)
 {
  */
 int SIMIX_req_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_RDV_COMM_COUNT_BY_HOST; 
-  req.rdv_comm_count_by_host.rdv = rdv;
-  req.rdv_comm_count_by_host.host = host;
+  req->call = REQ_RDV_COMM_COUNT_BY_HOST;
+  req->rdv_comm_count_by_host.rdv = rdv;
+  req->rdv_comm_count_by_host.host = host;

 
 

-  SIMIX_request_push(&req);
-  return req.rdv_comm_count_by_host.result;
+  SIMIX_request_push();
+  return req->rdv_comm_count_by_host.result;

 }
 
 /**
 }
 
 /**


@@ -587,107 +587,107 @@ int SIMIX_req_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host)
  */
 smx_action_t SIMIX_req_rdv_get_head(smx_rdv_t rdv)
 {
  */
 smx_action_t SIMIX_req_rdv_get_head(smx_rdv_t rdv)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_RDV_GET_HEAD; 
-  req.rdv_get_head.rdv = rdv;
+  req->call = REQ_RDV_GET_HEAD;
+  req->rdv_get_head.rdv = rdv;

 
 

-  SIMIX_request_push(&req);
-  return req.rdv_get_head.result;
+  SIMIX_request_push();
+  return req->rdv_get_head.result;

 }
 
 smx_action_t SIMIX_req_comm_isend(smx_rdv_t rdv, double task_size, double rate,
                               void *src_buff, size_t src_buff_size,
                               int (*match_fun)(void *, void *), void *data)
 {
 }
 
 smx_action_t SIMIX_req_comm_isend(smx_rdv_t rdv, double task_size, double rate,
                               void *src_buff, size_t src_buff_size,
                               int (*match_fun)(void *, void *), void *data)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
   xbt_assert0(rdv, "No rendez-vous point defined for isend");
 
 
   xbt_assert0(rdv, "No rendez-vous point defined for isend");
 

-  req.call = REQ_COMM_ISEND;
-  req.comm_isend.rdv = rdv;
-  req.comm_isend.task_size = task_size;
-  req.comm_isend.rate = rate;
-  req.comm_isend.src_buff = src_buff;
-  req.comm_isend.src_buff_size = src_buff_size;
-  req.comm_isend.match_fun = match_fun;
-  req.comm_isend.data = data;
+  req->call = REQ_COMM_ISEND;
+  req->comm_isend.rdv = rdv;
+  req->comm_isend.task_size = task_size;
+  req->comm_isend.rate = rate;
+  req->comm_isend.src_buff = src_buff;
+  req->comm_isend.src_buff_size = src_buff_size;
+  req->comm_isend.match_fun = match_fun;
+  req->comm_isend.data = data;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_isend.result;
+  SIMIX_request_push();
+  return req->comm_isend.result;

 }
 
 smx_action_t SIMIX_req_comm_irecv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size,
                                                                  int (*match_fun)(void *, void *), void *data)
 {
 }
 
 smx_action_t SIMIX_req_comm_irecv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size,
                                                                  int (*match_fun)(void *, void *), void *data)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
   xbt_assert0(rdv, "No rendez-vous point defined for isend");
 
 
   xbt_assert0(rdv, "No rendez-vous point defined for isend");
 

-  req.call = REQ_COMM_IRECV;
-  req.comm_irecv.rdv = rdv;
-  req.comm_irecv.dst_buff = dst_buff;
-  req.comm_irecv.dst_buff_size = dst_buff_size;
-  req.comm_irecv.match_fun = match_fun;
-  req.comm_irecv.data = data;
+  req->call = REQ_COMM_IRECV;
+  req->comm_irecv.rdv = rdv;
+  req->comm_irecv.dst_buff = dst_buff;
+  req->comm_irecv.dst_buff_size = dst_buff_size;
+  req->comm_irecv.match_fun = match_fun;
+  req->comm_irecv.data = data;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_irecv.result;
+  SIMIX_request_push();
+  return req->comm_irecv.result;

 }
 
 void SIMIX_req_comm_destroy(smx_action_t comm)
 {
 }
 
 void SIMIX_req_comm_destroy(smx_action_t comm)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_DESTROY;
-  req.comm_destroy.comm = comm;
+  req->call = REQ_COMM_DESTROY;
+  req->comm_destroy.comm = comm;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 void SIMIX_req_comm_cancel(smx_action_t comm)
 {
 }
 
 void SIMIX_req_comm_cancel(smx_action_t comm)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_CANCEL;
-  req.comm_cancel.comm = comm;
+  req->call = REQ_COMM_CANCEL;
+  req->comm_cancel.comm = comm;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 unsigned int SIMIX_req_comm_waitany(xbt_dynar_t comms)
 {
 }
 
 unsigned int SIMIX_req_comm_waitany(xbt_dynar_t comms)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_WAITANY;
-  req.comm_waitany.comms = comms;
+  req->call = REQ_COMM_WAITANY;
+  req->comm_waitany.comms = comms;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_waitany.result;
+  SIMIX_request_push();
+  return req->comm_waitany.result;

 }
 
 int SIMIX_req_comm_testany(xbt_dynar_t comms)
 {
 }
 
 int SIMIX_req_comm_testany(xbt_dynar_t comms)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

   if (xbt_dynar_length(comms)==0)
     return -1;
 
   if (xbt_dynar_length(comms)==0)
     return -1;
 

-  req.call = REQ_COMM_TESTANY;
-  req.comm_testany.comms = comms;
+  req->call = REQ_COMM_TESTANY;
+  req->comm_testany.comms = comms;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_testany.result;
+  SIMIX_request_push();
+  return req->comm_testany.result;

 }
 
 void SIMIX_req_comm_wait(smx_action_t comm, double timeout)
 {
 }
 
 void SIMIX_req_comm_wait(smx_action_t comm, double timeout)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_WAIT;
-  req.comm_wait.comm = comm;
-  req.comm_wait.timeout = timeout;
+  req->call = REQ_COMM_WAIT;
+  req->comm_wait.comm = comm;
+  req->comm_wait.timeout = timeout;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 #ifdef HAVE_TRACING
 }
 
 #ifdef HAVE_TRACING


@@ -700,340 +700,340 @@ void SIMIX_req_comm_wait(smx_action_t comm, double timeout)
  */
 void SIMIX_req_set_category(smx_action_t action, const char *category)
 {
  */
 void SIMIX_req_set_category(smx_action_t action, const char *category)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_SET_CATEGORY;
-  req.set_category.action = action;
-  req.set_category.category = category;
+  req->call = REQ_SET_CATEGORY;
+  req->set_category.action = action;
+  req->set_category.category = category;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 #endif
 
 int SIMIX_req_comm_test(smx_action_t comm)
 {
 }
 #endif
 
 int SIMIX_req_comm_test(smx_action_t comm)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_TEST;
-  req.comm_test.comm = comm;
+  req->call = REQ_COMM_TEST;
+  req->comm_test.comm = comm;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_test.result;
+  SIMIX_request_push();
+  return req->comm_test.result;

 }
 
 double SIMIX_req_comm_get_remains(smx_action_t comm)
 {
 }
 
 double SIMIX_req_comm_get_remains(smx_action_t comm)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_GET_REMAINS;
-  req.comm_get_remains.comm = comm;
+  req->call = REQ_COMM_GET_REMAINS;
+  req->comm_get_remains.comm = comm;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_get_remains.result;
+  SIMIX_request_push();
+  return req->comm_get_remains.result;

 }
 
 e_smx_state_t SIMIX_req_comm_get_state(smx_action_t comm)
 {
 }
 
 e_smx_state_t SIMIX_req_comm_get_state(smx_action_t comm)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_GET_STATE;
-  req.comm_get_state.comm = comm;
+  req->call = REQ_COMM_GET_STATE;
+  req->comm_get_state.comm = comm;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_get_state.result;
+  SIMIX_request_push();
+  return req->comm_get_state.result;

 }
 
 void *SIMIX_req_comm_get_src_data(smx_action_t comm)
 {
 }
 
 void *SIMIX_req_comm_get_src_data(smx_action_t comm)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_GET_SRC_DATA;
-  req.comm_get_src_data.comm = comm;
+  req->call = REQ_COMM_GET_SRC_DATA;
+  req->comm_get_src_data.comm = comm;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_get_src_data.result;
+  SIMIX_request_push();
+  return req->comm_get_src_data.result;

 }
 
 void *SIMIX_req_comm_get_dst_data(smx_action_t comm)
 {
 }
 
 void *SIMIX_req_comm_get_dst_data(smx_action_t comm)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_GET_DST_DATA;
-  req.comm_get_dst_data.comm = comm;
+  req->call = REQ_COMM_GET_DST_DATA;
+  req->comm_get_dst_data.comm = comm;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_get_dst_data.result;
+  SIMIX_request_push();
+  return req->comm_get_dst_data.result;

 }
 
 void *SIMIX_req_comm_get_src_buff(smx_action_t comm)
 {
 }
 
 void *SIMIX_req_comm_get_src_buff(smx_action_t comm)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_GET_SRC_BUFF;
-  req.comm_get_src_buff.comm = comm;
+  req->call = REQ_COMM_GET_SRC_BUFF;
+  req->comm_get_src_buff.comm = comm;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_get_src_buff.result;
+  SIMIX_request_push();
+  return req->comm_get_src_buff.result;

 }
 
 void *SIMIX_req_comm_get_dst_buff(smx_action_t comm)
 {
 }
 
 void *SIMIX_req_comm_get_dst_buff(smx_action_t comm)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_GET_DST_BUFF;
-  req.comm_get_dst_buff.comm = comm;
+  req->call = REQ_COMM_GET_DST_BUFF;
+  req->comm_get_dst_buff.comm = comm;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_get_dst_buff.result;
+  SIMIX_request_push();
+  return req->comm_get_dst_buff.result;

 }
 
 size_t SIMIX_req_comm_get_src_buff_size(smx_action_t comm)
 {
 }
 
 size_t SIMIX_req_comm_get_src_buff_size(smx_action_t comm)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_GET_SRC_BUFF_SIZE;
-  req.comm_get_src_buff_size.comm = comm;
+  req->call = REQ_COMM_GET_SRC_BUFF_SIZE;
+  req->comm_get_src_buff_size.comm = comm;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_get_src_buff_size.result;
+  SIMIX_request_push();
+  return req->comm_get_src_buff_size.result;

 }
 
 size_t SIMIX_req_comm_get_dst_buff_size(smx_action_t comm)
 {
 }
 
 size_t SIMIX_req_comm_get_dst_buff_size(smx_action_t comm)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_GET_DST_BUFF_SIZE;
-  req.comm_get_dst_buff_size.comm = comm;
+  req->call = REQ_COMM_GET_DST_BUFF_SIZE;
+  req->comm_get_dst_buff_size.comm = comm;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_get_dst_buff_size.result;
+  SIMIX_request_push();
+  return req->comm_get_dst_buff_size.result;

 }
 
 smx_process_t SIMIX_req_comm_get_src_proc(smx_action_t comm)
 {
 }
 
 smx_process_t SIMIX_req_comm_get_src_proc(smx_action_t comm)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_GET_SRC_PROC;
-  req.comm_get_src_proc.comm = comm;
+  req->call = REQ_COMM_GET_SRC_PROC;
+  req->comm_get_src_proc.comm = comm;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_get_src_proc.result;
+  SIMIX_request_push();
+  return req->comm_get_src_proc.result;

 }
 
 smx_process_t SIMIX_req_comm_get_dst_proc(smx_action_t comm)
 {
 }
 
 smx_process_t SIMIX_req_comm_get_dst_proc(smx_action_t comm)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_GET_DST_PROC;
-  req.comm_get_dst_proc.comm = comm;
+  req->call = REQ_COMM_GET_DST_PROC;
+  req->comm_get_dst_proc.comm = comm;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_get_dst_proc.result;
+  SIMIX_request_push();
+  return req->comm_get_dst_proc.result;

 }
 
 #ifdef HAVE_LATENCY_BOUND_TRACKING
 int SIMIX_req_comm_is_latency_bounded(smx_action_t comm)
 {
 }
 
 #ifdef HAVE_LATENCY_BOUND_TRACKING
 int SIMIX_req_comm_is_latency_bounded(smx_action_t comm)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COMM_IS_LATENCY_BOUNDED;
-  req.comm_is_latency_bounded.comm = comm;
+  req->call = REQ_COMM_IS_LATENCY_BOUNDED;
+  req->comm_is_latency_bounded.comm = comm;

 
 

-  SIMIX_request_push(&req);
-  return req.comm_is_latency_bounded.result;
+  SIMIX_request_push();
+  return req->comm_is_latency_bounded.result;

 }
 #endif
 
 smx_mutex_t SIMIX_req_mutex_init(void)
 {
 }
 #endif
 
 smx_mutex_t SIMIX_req_mutex_init(void)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_MUTEX_INIT;
+  req->call = REQ_MUTEX_INIT;

 
 

-  SIMIX_request_push(&req);
-  return req.mutex_init.result;
+  SIMIX_request_push();
+  return req->mutex_init.result;

 }
 
 void SIMIX_req_mutex_destroy(smx_mutex_t mutex)
 {
 }
 
 void SIMIX_req_mutex_destroy(smx_mutex_t mutex)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_MUTEX_DESTROY;
-  req.mutex_destroy.mutex = mutex;
+  req->call = REQ_MUTEX_DESTROY;
+  req->mutex_destroy.mutex = mutex;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 void SIMIX_req_mutex_lock(smx_mutex_t mutex)
 {
 }
 
 void SIMIX_req_mutex_lock(smx_mutex_t mutex)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_MUTEX_LOCK;
-  req.mutex_lock.mutex = mutex;
+  req->call = REQ_MUTEX_LOCK;
+  req->mutex_lock.mutex = mutex;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 int SIMIX_req_mutex_trylock(smx_mutex_t mutex)
 {
 }
 
 int SIMIX_req_mutex_trylock(smx_mutex_t mutex)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_MUTEX_TRYLOCK;
-  req.mutex_trylock.mutex = mutex;
+  req->call = REQ_MUTEX_TRYLOCK;
+  req->mutex_trylock.mutex = mutex;

 
 

-  SIMIX_request_push(&req);
-  return req.mutex_trylock.result;
+  SIMIX_request_push();
+  return req->mutex_trylock.result;

 }
 
 void SIMIX_req_mutex_unlock(smx_mutex_t mutex)
 {
 }
 
 void SIMIX_req_mutex_unlock(smx_mutex_t mutex)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_MUTEX_UNLOCK;
-  req.mutex_unlock.mutex = mutex;
+  req->call = REQ_MUTEX_UNLOCK;
+  req->mutex_unlock.mutex = mutex;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 
 smx_cond_t SIMIX_req_cond_init(void)
 {
 }
 
 
 smx_cond_t SIMIX_req_cond_init(void)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COND_INIT;
+  req->call = REQ_COND_INIT;

 
 

-  SIMIX_request_push(&req);
-  return req.cond_init.result;
+  SIMIX_request_push();
+  return req->cond_init.result;

 }
 
 void SIMIX_req_cond_destroy(smx_cond_t cond)
 {
 }
 
 void SIMIX_req_cond_destroy(smx_cond_t cond)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COND_DESTROY;
-  req.cond_destroy.cond = cond;
+  req->call = REQ_COND_DESTROY;
+  req->cond_destroy.cond = cond;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 void SIMIX_req_cond_signal(smx_cond_t cond)
 {
 }
 
 void SIMIX_req_cond_signal(smx_cond_t cond)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COND_SIGNAL;
-  req.cond_signal.cond = cond;
+  req->call = REQ_COND_SIGNAL;
+  req->cond_signal.cond = cond;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 void SIMIX_req_cond_wait(smx_cond_t cond, smx_mutex_t mutex)
 {
 }
 
 void SIMIX_req_cond_wait(smx_cond_t cond, smx_mutex_t mutex)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COND_WAIT;
-  req.cond_wait.cond = cond;
-  req.cond_wait.mutex = mutex;
+  req->call = REQ_COND_WAIT;
+  req->cond_wait.cond = cond;
+  req->cond_wait.mutex = mutex;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 void SIMIX_req_cond_wait_timeout(smx_cond_t cond,
                                  smx_mutex_t mutex,
                                  double timeout)
 {
 }
 
 void SIMIX_req_cond_wait_timeout(smx_cond_t cond,
                                  smx_mutex_t mutex,
                                  double timeout)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COND_WAIT_TIMEOUT;
-  req.cond_wait_timeout.cond = cond;
-  req.cond_wait_timeout.mutex = mutex;
-  req.cond_wait_timeout.timeout = timeout;
+  req->call = REQ_COND_WAIT_TIMEOUT;
+  req->cond_wait_timeout.cond = cond;
+  req->cond_wait_timeout.mutex = mutex;
+  req->cond_wait_timeout.timeout = timeout;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 void SIMIX_req_cond_broadcast(smx_cond_t cond)
 {
 }
 
 void SIMIX_req_cond_broadcast(smx_cond_t cond)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_COND_BROADCAST;
-  req.cond_broadcast.cond = cond;
+  req->call = REQ_COND_BROADCAST;
+  req->cond_broadcast.cond = cond;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 
 smx_sem_t SIMIX_req_sem_init(int capacity)
 {
 }
 
 
 smx_sem_t SIMIX_req_sem_init(int capacity)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_SEM_INIT;
-  req.sem_init.capacity = capacity;
+  req->call = REQ_SEM_INIT;
+  req->sem_init.capacity = capacity;

 
 

-  SIMIX_request_push(&req);
-  return req.sem_init.result;
+  SIMIX_request_push();
+  return req->sem_init.result;

 }
 
 void SIMIX_req_sem_destroy(smx_sem_t sem)
 {
 }
 
 void SIMIX_req_sem_destroy(smx_sem_t sem)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_SEM_DESTROY;
-  req.sem_destroy.sem = sem;
+  req->call = REQ_SEM_DESTROY;
+  req->sem_destroy.sem = sem;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 void SIMIX_req_sem_release(smx_sem_t sem)
 {
 }
 
 void SIMIX_req_sem_release(smx_sem_t sem)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_SEM_RELEASE;
-  req.sem_release.sem = sem;
+  req->call = REQ_SEM_RELEASE;
+  req->sem_release.sem = sem;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 int SIMIX_req_sem_would_block(smx_sem_t sem)
 {
 }
 
 int SIMIX_req_sem_would_block(smx_sem_t sem)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_SEM_WOULD_BLOCK;
-  req.sem_would_block.sem = sem;
+  req->call = REQ_SEM_WOULD_BLOCK;
+  req->sem_would_block.sem = sem;

 
 

-  SIMIX_request_push(&req);
-  return req.sem_would_block.result;
+  SIMIX_request_push();
+  return req->sem_would_block.result;

 }
 
 void SIMIX_req_sem_acquire(smx_sem_t sem)
 {
 }
 
 void SIMIX_req_sem_acquire(smx_sem_t sem)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_SEM_ACQUIRE;
-  req.sem_acquire.sem = sem;
+  req->call = REQ_SEM_ACQUIRE;
+  req->sem_acquire.sem = sem;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 void SIMIX_req_sem_acquire_timeout(smx_sem_t sem, double timeout)
 {
 }
 
 void SIMIX_req_sem_acquire_timeout(smx_sem_t sem, double timeout)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_SEM_ACQUIRE_TIMEOUT;
-  req.sem_acquire_timeout.sem = sem;
-  req.sem_acquire_timeout.timeout = timeout;
+  req->call = REQ_SEM_ACQUIRE_TIMEOUT;
+  req->sem_acquire_timeout.sem = sem;
+  req->sem_acquire_timeout.timeout = timeout;

 
 

-  SIMIX_request_push(&req);
+  SIMIX_request_push();

 }
 
 int SIMIX_req_sem_get_capacity(smx_sem_t sem)
 {
 }
 
 int SIMIX_req_sem_get_capacity(smx_sem_t sem)
 {

-  s_smx_req_t req;
+  smx_req_t req = SIMIX_req_mine();

 
 

-  req.call = REQ_SEM_GET_CAPACITY;
-  req.sem_get_capacity.sem = sem;
+  req->call = REQ_SEM_GET_CAPACITY;
+  req->sem_get_capacity.sem = sem;

 
 

-  SIMIX_request_push(&req);
-  return req.sem_get_capacity.result;
+  SIMIX_request_push();
+  return req->sem_get_capacity.result;

 }
 
 
 }