SIMIX: add a redundant parameter to avoid repeated SIMIX_process_self()

diff --git a/include/simix/simix.h b/include/simix/simix.h
index 7c6a70a..8d7a03d 100644 (file)
--- a/include/simix/simix.h
+++ b/include/simix/simix.h
@@ -63,8 +63,8 @@ XBT_PUBLIC(void*) SIMIX_host_self_get_data(void);
 XBT_PUBLIC(int) SIMIX_process_count(void);
 XBT_INLINE XBT_PUBLIC(smx_process_t) SIMIX_process_self(void);
 XBT_PUBLIC(const char*) SIMIX_process_self_get_name(void);
 XBT_PUBLIC(int) SIMIX_process_count(void);
 XBT_INLINE XBT_PUBLIC(smx_process_t) SIMIX_process_self(void);
 XBT_PUBLIC(const char*) SIMIX_process_self_get_name(void);

-XBT_PUBLIC(void) SIMIX_process_self_set_data(void *data);
-XBT_PUBLIC(void*) SIMIX_process_self_get_data(void);
+XBT_PUBLIC(void) SIMIX_process_self_set_data(smx_process_t self, void *data);
+XBT_PUBLIC(void*) SIMIX_process_self_get_data(smx_process_t self);

 XBT_PUBLIC(smx_context_t) SIMIX_process_get_context(smx_process_t);
 XBT_PUBLIC(void) SIMIX_process_set_context(smx_process_t p,smx_context_t c);
 
 XBT_PUBLIC(smx_context_t) SIMIX_process_get_context(smx_process_t);
 XBT_PUBLIC(void) SIMIX_process_set_context(smx_process_t p,smx_context_t c);
 

diff --git a/src/gras/Virtu/sg_process.c b/src/gras/Virtu/sg_process.c
index c6446ee..3d70daa 100644 (file)
--- a/src/gras/Virtu/sg_process.c
+++ b/src/gras/Virtu/sg_process.c
@@ -38,6 +38,7 @@ void gras_agent_spawn(const char *name,
 
 void gras_process_init()
 {
 
 void gras_process_init()
 {

+  smx_process_t self = SIMIX_process_self();

   gras_hostdata_t *hd =
       (gras_hostdata_t *) SIMIX_host_self_get_data();
   gras_procdata_t *pd = xbt_new0(gras_procdata_t, 1);
   gras_hostdata_t *hd =
       (gras_hostdata_t *) SIMIX_host_self_get_data();
   gras_procdata_t *pd = xbt_new0(gras_procdata_t, 1);


@@ -54,13 +55,13 @@ void gras_process_init()
     hd->refcount++;
   }
 
     hd->refcount++;
   }
 

-  SIMIX_process_self_set_data((void *) pd);
+  SIMIX_process_self_set_data(self, (void *) pd);

   gras_procdata_init();
 
   trp_pd = (gras_trp_procdata_t) gras_libdata_by_name("gras_trp");
   pd->pid = pid;
 
   gras_procdata_init();
 
   trp_pd = (gras_trp_procdata_t) gras_libdata_by_name("gras_trp");
   pd->pid = pid;
 

-  if (SIMIX_process_self() != NULL) {
+  if (self != NULL) {

     pd->ppid = gras_os_getpid();
   } else
     pd->ppid = -1;
     pd->ppid = gras_os_getpid();
   } else
     pd->ppid = -1;


@@ -179,7 +180,7 @@ xbt_dict_t gras_process_properties(void)
 int gras_os_getpid(void)
 {
   gras_procdata_t *data;
 int gras_os_getpid(void)
 {
   gras_procdata_t *data;

-  data = (gras_procdata_t *) SIMIX_process_self_get_data();
+  data = (gras_procdata_t *) SIMIX_process_self_get_data(SIMIX_process_self());

   if (data != NULL)
     return data->pid;
 
   if (data != NULL)
     return data->pid;
 

diff --git a/src/msg/msg_gos.c b/src/msg/msg_gos.c
index aa91522..ff040ca 100644 (file)
--- a/src/msg/msg_gos.c
+++ b/src/msg/msg_gos.c
@@ -62,16 +62,18 @@ MSG_error_t MSG_task_execute(m_task_t task)
 #endif
     return MSG_OK;
   }
 #endif
     return MSG_OK;
   }

+
+  m_process_t self = SIMIX_process_self();
+  p_simdata = SIMIX_process_self_get_data(self);

   simdata->isused=1;
   simdata->compute =
   simdata->isused=1;
   simdata->compute =

-      SIMIX_req_host_execute(task->name, SIMIX_host_self(),
+      SIMIX_req_host_execute(task->name, p_simdata->m_host->simdata->smx_host,

                            simdata->computation_amount,
                            simdata->priority);
 #ifdef HAVE_TRACING
   SIMIX_req_set_category(simdata->compute, task->category);
 #endif
 
                            simdata->computation_amount,
                            simdata->priority);
 #ifdef HAVE_TRACING
   SIMIX_req_set_category(simdata->compute, task->category);
 #endif
 

-  p_simdata = SIMIX_process_self_get_data();

   p_simdata->waiting_action = simdata->compute;
   comp_state = SIMIX_req_host_execution_wait(simdata->compute);
   p_simdata->waiting_action = NULL;
   p_simdata->waiting_action = simdata->compute;
   comp_state = SIMIX_req_host_execution_wait(simdata->compute);
   p_simdata->waiting_action = NULL;


@@ -171,7 +173,7 @@ MSG_error_t MSG_parallel_task_execute(m_task_t task)
   CHECK_HOST();
 
   simdata = task->simdata;
   CHECK_HOST();
 
   simdata = task->simdata;

-  p_simdata = SIMIX_process_self_get_data();
+  p_simdata = SIMIX_process_self_get_data(SIMIX_process_self());

 
   xbt_assert((!simdata->compute)
               && (task->simdata->isused == 0),
 
   xbt_assert((!simdata->compute)
               && (task->simdata->isused == 0),


@@ -385,6 +387,7 @@ msg_comm_t MSG_task_isend(m_task_t task, const char *alias)
 {
   return MSG_task_isend_with_matching(task,alias,NULL,NULL);
 }
 {
   return MSG_task_isend_with_matching(task,alias,NULL,NULL);
 }

+

 /** \ingroup msg_gos_functions
  * \brief Sends a task on a mailbox, with support for matching requests
  *
 /** \ingroup msg_gos_functions
  * \brief Sends a task on a mailbox, with support for matching requests
  *


@@ -412,7 +415,7 @@ XBT_INLINE msg_comm_t MSG_task_isend_with_matching(m_task_t task, const char *al
   /* Prepare the task to send */
   t_simdata = task->simdata;
   t_simdata->sender = process;
   /* Prepare the task to send */
   t_simdata = task->simdata;
   t_simdata->sender = process;

-  t_simdata->source = MSG_host_self();
+  t_simdata->source = ((simdata_process_t) SIMIX_process_self_get_data(process))->m_host;

 
   xbt_assert(t_simdata->isused == 0,
               "This task is still being used somewhere else. You cannot send it now. Go fix your code!");
 
   xbt_assert(t_simdata->isused == 0,
               "This task is still being used somewhere else. You cannot send it now. Go fix your code!");


@@ -467,7 +470,7 @@ void MSG_task_dsend(m_task_t task, const char *alias, void_f_pvoid_t cleanup)
   /* Prepare the task to send */
   t_simdata = task->simdata;
   t_simdata->sender = process;
   /* Prepare the task to send */
   t_simdata = task->simdata;
   t_simdata->sender = process;

-  t_simdata->source = MSG_host_self();
+  t_simdata->source = ((simdata_process_t) SIMIX_process_self_get_data(process))->m_host;

 
   xbt_assert(t_simdata->isused == 0,
               "This task is still being used somewhere else. You cannot send it now. Go fix your code!");
 
   xbt_assert(t_simdata->isused == 0,
               "This task is still being used somewhere else. You cannot send it now. Go fix your code!");

diff --git a/src/msg/msg_host.c b/src/msg/msg_host.c
index bcd8b8f..5ca1eba 100644 (file)
--- a/src/msg/msg_host.c
+++ b/src/msg/msg_host.c
@@ -117,7 +117,7 @@ const char *MSG_host_get_name(m_host_t host)
  */
 m_host_t MSG_host_self(void)
 {
  */
 m_host_t MSG_host_self(void)
 {

-  return MSG_process_get_host(MSG_process_self());
+  return MSG_process_get_host(NULL);

 }
 
 /** \ingroup m_host_management
 }
 
 /** \ingroup m_host_management

diff --git a/src/msg/msg_mailbox.c b/src/msg/msg_mailbox.c
index 41e6f14..0990c45 100644 (file)
--- a/src/msg/msg_mailbox.c
+++ b/src/msg/msg_mailbox.c
@@ -130,7 +130,7 @@ MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, m_task_t task,
   MSG_error_t ret = MSG_OK;
   simdata_task_t t_simdata = NULL;
   m_process_t process = MSG_process_self();
   MSG_error_t ret = MSG_OK;
   simdata_task_t t_simdata = NULL;
   m_process_t process = MSG_process_self();

-  simdata_process_t p_simdata = SIMIX_process_self_get_data();
+  simdata_process_t p_simdata = SIMIX_process_self_get_data(process);

   CHECK_HOST();
 
 #ifdef HAVE_TRACING
   CHECK_HOST();
 
 #ifdef HAVE_TRACING


@@ -140,7 +140,7 @@ MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, m_task_t task,
   /* Prepare the task to send */
   t_simdata = task->simdata;
   t_simdata->sender = process;
   /* Prepare the task to send */
   t_simdata = task->simdata;
   t_simdata->sender = process;

-  t_simdata->source = MSG_host_self();
+  t_simdata->source = ((simdata_process_t) SIMIX_process_self_get_data(process))->m_host;

 
   xbt_assert(t_simdata->isused == 0,
               "This task is still being used somewhere else. You cannot send it now. Go fix your code!");
 
   xbt_assert(t_simdata->isused == 0,
               "This task is still being used somewhere else. You cannot send it now. Go fix your code!");

diff --git a/src/msg/msg_private.h b/src/msg/msg_private.h
index ef8b829..c08ac68 100644 (file)
--- a/src/msg/msg_private.h
+++ b/src/msg/msg_private.h
@@ -94,9 +94,9 @@ XBT_PUBLIC_DATA(MSG_Global_t) msg_global;
 /*************************************************************/
 
 #define PROCESS_SET_ERRNO(val) \
 /*************************************************************/
 
 #define PROCESS_SET_ERRNO(val) \

-  (((simdata_process_t) SIMIX_process_self_get_data())->last_errno=val)
+  (((simdata_process_t) SIMIX_process_self_get_data(SIMIX_process_self()))->last_errno=val)

 #define PROCESS_GET_ERRNO() \
 #define PROCESS_GET_ERRNO() \

-  (((simdata_process_t) SIMIX_process_self_get_data())->last_errno)
+  (((simdata_process_t) SIMIX_process_self_get_data(SIMIX_process_self()))->last_errno)

 #define MSG_RETURN(val) do {PROCESS_SET_ERRNO(val);return(val);} while(0)
 /* #define CHECK_ERRNO()  ASSERT((PROCESS_GET_ERRNO()!=MSG_HOST_FAILURE),"Host failed, you cannot call this function.") */
 
 #define MSG_RETURN(val) do {PROCESS_SET_ERRNO(val);return(val);} while(0)
 /* #define CHECK_ERRNO()  ASSERT((PROCESS_GET_ERRNO()!=MSG_HOST_FAILURE),"Host failed, you cannot call this function.") */
 

diff --git a/src/msg/msg_process.c b/src/msg/msg_process.c
index 93e7aca..8a2f8ea 100644 (file)
--- a/src/msg/msg_process.c
+++ b/src/msg/msg_process.c
@@ -32,7 +32,7 @@ void MSG_process_cleanup_from_SIMIX(smx_process_t smx_proc)
 
   if (smx_proc == SIMIX_process_self()) {
     /* avoid a SIMIX request if this function is called by the process itself */
 
   if (smx_proc == SIMIX_process_self()) {
     /* avoid a SIMIX request if this function is called by the process itself */

-    msg_proc = SIMIX_process_self_get_data();
+    msg_proc = SIMIX_process_self_get_data(smx_proc);

   }
   else {
     msg_proc = SIMIX_req_process_get_data(smx_proc);
   }
   else {
     msg_proc = SIMIX_req_process_get_data(smx_proc);


@@ -258,16 +258,19 @@ MSG_error_t MSG_process_set_data(m_process_t process, void *data)
 
 /** \ingroup m_process_management
  * \brief Return the location on which an agent is running.
 
 /** \ingroup m_process_management
  * \brief Return the location on which an agent is running.

- *
- * This function checks whether \a process is a valid pointer or not
-   and return the m_host_t corresponding to the location on which \a
-   process is running.
+ * \param process a process (NULL means the current one)
+ * \return the m_host_t corresponding to the location on which \a
+ * process is running.

  */
 m_host_t MSG_process_get_host(m_process_t process)
 {
  */
 m_host_t MSG_process_get_host(m_process_t process)
 {

-  xbt_assert(process != NULL, "Invalid parameter");
-
-  simdata_process_t simdata = SIMIX_req_process_get_data(process);
+  simdata_process_t simdata;
+  if (process == NULL) {
+    simdata = SIMIX_process_self_get_data(SIMIX_process_self());
+  }
+  else {
+    simdata = SIMIX_req_process_get_data(process);
+  }

   return simdata->m_host;
 }
 
   return simdata->m_host;
 }
 

diff --git a/src/simix/process_private.h b/src/simix/process_private.h
index cfc9501..7d2dd13 100644 (file)
--- a/src/simix/process_private.h
+++ b/src/simix/process_private.h
@@ -59,7 +59,7 @@ smx_process_t SIMIX_process_create_from_wrapper(smx_process_arg_t args);
 void SIMIX_create_maestro_process(void);
 void SIMIX_process_cleanup(smx_process_t arg);
 void SIMIX_process_empty_trash(void);
 void SIMIX_create_maestro_process(void);
 void SIMIX_process_cleanup(smx_process_t arg);
 void SIMIX_process_empty_trash(void);

-void SIMIX_process_yield(void);
+void SIMIX_process_yield(smx_process_t self);

 xbt_running_ctx_t *SIMIX_process_get_running_context(void);
 void SIMIX_process_exception_terminate(xbt_ex_t * e);
 void SIMIX_pre_process_change_host(smx_process_t process,
 xbt_running_ctx_t *SIMIX_process_get_running_context(void);
 void SIMIX_process_exception_terminate(xbt_ex_t * e);
 void SIMIX_pre_process_change_host(smx_process_t process,

diff --git a/src/simix/smurf_private.h b/src/simix/smurf_private.h
index 251b40f..40ad900 100644 (file)
--- a/src/simix/smurf_private.h
+++ b/src/simix/smurf_private.h
@@ -504,7 +504,7 @@ typedef struct s_smx_req {
 
 /******************************** General *************************************/
 
 
 /******************************** General *************************************/
 

-void SIMIX_request_push(void);
+void SIMIX_request_push(smx_process_t self);

 void SIMIX_request_answer(smx_req_t);
 void SIMIX_request_pre(smx_req_t, int);
 void SIMIX_request_post(smx_action_t);
 void SIMIX_request_answer(smx_req_t);
 void SIMIX_request_pre(smx_req_t, int);
 void SIMIX_request_post(smx_action_t);

diff --git a/src/simix/smx_process.c b/src/simix/smx_process.c
index f02b306..d4bb60a 100644 (file)
--- a/src/simix/smx_process.c
+++ b/src/simix/smx_process.c
@@ -186,6 +186,7 @@ void SIMIX_process_create(smx_process_t *process,
     (*process)->smx_host = host;
     (*process)->data = data;
     (*process)->comms = xbt_fifo_new();
     (*process)->smx_host = host;
     (*process)->data = data;
     (*process)->comms = xbt_fifo_new();

+    (*process)->request.issuer = *process;

 
     XBT_VERB("Create context %s", (*process)->name);
     (*process)->context = SIMIX_context_new(code, argc, argv,
 
     XBT_VERB("Create context %s", (*process)->name);
     (*process)->context = SIMIX_context_new(code, argc, argv,


@@ -413,18 +414,21 @@ int SIMIX_process_count(void)
   return xbt_swag_size(simix_global->process_list);
 }
 
   return xbt_swag_size(simix_global->process_list);
 }
 

-void* SIMIX_process_self_get_data(void)
+void* SIMIX_process_self_get_data(smx_process_t self)

 {
 {

-  smx_process_t me = SIMIX_process_self();
-  if (!me) {
+  xbt_assert(self == SIMIX_process_self(), "This is not the current process");
+
+  if (!self) {

     return NULL;
   }
     return NULL;
   }

-  return SIMIX_process_get_data(me);
+  return SIMIX_process_get_data(self);

 }
 
 }
 

-void SIMIX_process_self_set_data(void *data)
+void SIMIX_process_self_set_data(smx_process_t self, void *data)

 {
 {

-  SIMIX_process_set_data(SIMIX_process_self(), data);
+  xbt_assert(self == SIMIX_process_self(), "This is not the current process");
+
+  SIMIX_process_set_data(self, data);

 }
 
 void* SIMIX_process_get_data(smx_process_t process)
 }
 
 void* SIMIX_process_get_data(smx_process_t process)


@@ -568,13 +572,15 @@ void SIMIX_process_sleep_resume(smx_action_t action)
 }
 
 /** 
 }
 
 /** 

- * Calling this function makes the process to yield.
- * Only the processes can call this function, giving back the control to maestro
+ * \brief Calling this function makes the process to yield.
+ *
+ * Only the current process can call this function, giving back the control to
+ * maestro.
+ *
+ * \param self the current process

  */
  */

-void SIMIX_process_yield(void)
+void SIMIX_process_yield(smx_process_t self)

 {
 {

-  smx_process_t self = SIMIX_process_self();
-

   XBT_DEBUG("Yield process '%s'", self->name);
 
   /* Go into sleep and return control to maestro */
   XBT_DEBUG("Yield process '%s'", self->name);
 
   /* Go into sleep and return control to maestro */

diff --git a/src/simix/smx_smurf.c b/src/simix/smx_smurf.c
index bd82cea..c307cda 100644 (file)
--- a/src/simix/smx_smurf.c
+++ b/src/simix/smx_smurf.c
@@ -5,24 +5,25 @@
 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)");
 

-/* 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;
 }
 
 XBT_INLINE smx_req_t SIMIX_req_mine()
 {
   smx_process_t issuer = SIMIX_process_self();
   return &issuer->request;
 }
 

-void SIMIX_request_push()
+/**
+ * \brief Makes the current process do a request to the kernel and yields
+ * until completion.
+ * \param self the current process
+ */
+void SIMIX_request_push(smx_process_t self)

 {
 {

-  smx_process_t issuer = SIMIX_process_self();
-
-  if (issuer != simix_global->maestro_process){
-    issuer->request.issuer = issuer;
-    XBT_DEBUG("Yield process '%s' on request of type %s (%d)", issuer->name,
-        SIMIX_request_name(issuer->request.call), issuer->request.call);
-    SIMIX_process_yield();
+  if (self != simix_global->maestro_process) {
+    XBT_DEBUG("Yield process '%s' on request of type %s (%d)", self->name,
+        SIMIX_request_name(self->request.call), self->request.call);
+    SIMIX_process_yield(self);

   } else {
   } else {

-    SIMIX_request_pre(&issuer->request, 0);
+    SIMIX_request_pre(&self->request, 0);

   }
 }
 
   }
 }
 

diff --git a/src/simix/smx_user.c b/src/simix/smx_user.c
index 4184a76..e8b691f 100644 (file)
--- a/src/simix/smx_user.c
+++ b/src/simix/smx_user.c
@@ -40,7 +40,7 @@ smx_host_t SIMIX_req_host_get_by_name(const char *name)
 
   req->call = REQ_HOST_GET_BY_NAME;
   req->host_get_by_name.name = name;
 
   req->call = REQ_HOST_GET_BY_NAME;
   req->host_get_by_name.name = name;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->host_get_by_name.result;
 }
 
   return req->host_get_by_name.result;
 }
 


@@ -56,7 +56,7 @@ const char* SIMIX_req_host_get_name(smx_host_t host)
 
   req->call = REQ_HOST_GET_NAME;
   req->host_get_name.host = host;
 
   req->call = REQ_HOST_GET_NAME;
   req->host_get_name.host = host;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->host_get_name.result;
 }
 
   return req->host_get_name.result;
 }
 


@@ -72,7 +72,7 @@ xbt_dict_t SIMIX_req_host_get_properties(smx_host_t host)
 
   req->call = REQ_HOST_GET_PROPERTIES;
   req->host_get_properties.host = host;
 
   req->call = REQ_HOST_GET_PROPERTIES;
   req->host_get_properties.host = host;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->host_get_properties.result;
 }
 
   return req->host_get_properties.result;
 }
 


@@ -89,7 +89,7 @@ double SIMIX_req_host_get_speed(smx_host_t host)
 
   req->call = REQ_HOST_GET_SPEED;
   req->host_get_speed.host = host;
 
   req->call = REQ_HOST_GET_SPEED;
   req->host_get_speed.host = host;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->host_get_speed.result;
 }
 
   return req->host_get_speed.result;
 }
 


@@ -104,7 +104,7 @@ double SIMIX_req_host_get_available_speed(smx_host_t host)
 
   req->call = REQ_HOST_GET_AVAILABLE_SPEED;
   req->host_get_available_speed.host = host;
 
   req->call = REQ_HOST_GET_AVAILABLE_SPEED;
   req->host_get_available_speed.host = host;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->host_get_available_speed.result;
 }
 
   return req->host_get_available_speed.result;
 }
 


@@ -121,7 +121,7 @@ int SIMIX_req_host_get_state(smx_host_t host)
 
   req->call = REQ_HOST_GET_STATE;
   req->host_get_state.host = host;
 
   req->call = REQ_HOST_GET_STATE;
   req->host_get_state.host = host;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->host_get_state.result;
 }
 
   return req->host_get_state.result;
 }
 


@@ -137,7 +137,7 @@ void* SIMIX_req_host_get_data(smx_host_t host)
 
   req->call = REQ_HOST_GET_DATA;
   req->host_get_data.host = host;
 
   req->call = REQ_HOST_GET_DATA;
   req->host_get_data.host = host;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->host_get_data.result;
 }
 
   return req->host_get_data.result;
 }
 


@@ -155,7 +155,7 @@ void SIMIX_req_host_set_data(smx_host_t host, void *data)
   req->call = REQ_HOST_SET_DATA;
   req->host_set_data.host = host;
   req->host_set_data.data = data;
   req->call = REQ_HOST_SET_DATA;
   req->host_set_data.host = host;
   req->host_set_data.data = data;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

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


@@ -183,7 +183,7 @@ smx_action_t SIMIX_req_host_execute(const char *name, smx_host_t host,
   req->host_execute.host = host;
   req->host_execute.computation_amount = computation_amount;
   req->host_execute.priority = priority;
   req->host_execute.host = host;
   req->host_execute.computation_amount = computation_amount;
   req->host_execute.priority = priority;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->host_execute.result;
 }
 
   return req->host_execute.result;
 }
 


@@ -231,7 +231,7 @@ smx_action_t SIMIX_req_host_parallel_execute(const char *name,
   req->host_parallel_execute.communication_amount = communication_amount;
   req->host_parallel_execute.amount = amount;
   req->host_parallel_execute.rate = rate;
   req->host_parallel_execute.communication_amount = communication_amount;
   req->host_parallel_execute.amount = amount;
   req->host_parallel_execute.rate = rate;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->host_parallel_execute.result;
 }
 
   return req->host_parallel_execute.result;
 }
 


@@ -247,7 +247,7 @@ void SIMIX_req_host_execution_destroy(smx_action_t execution)
 
   req->call = REQ_HOST_EXECUTION_DESTROY;
   req->host_execution_destroy.execution = execution;
 
   req->call = REQ_HOST_EXECUTION_DESTROY;
   req->host_execution_destroy.execution = execution;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

 }
 
 /**
 }
 
 /**


@@ -262,7 +262,7 @@ void SIMIX_req_host_execution_cancel(smx_action_t execution)
 
   req->call = REQ_HOST_EXECUTION_CANCEL;
   req->host_execution_cancel.execution = execution;
 
   req->call = REQ_HOST_EXECUTION_CANCEL;
   req->host_execution_cancel.execution = execution;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

 }
 
 /**
 }
 
 /**


@@ -277,7 +277,7 @@ double SIMIX_req_host_execution_get_remains(smx_action_t execution)
 
   req->call = REQ_HOST_EXECUTION_GET_REMAINS;
   req->host_execution_get_remains.execution = execution;
 
   req->call = REQ_HOST_EXECUTION_GET_REMAINS;
   req->host_execution_get_remains.execution = execution;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->host_execution_get_remains.result;
 }
 
   return req->host_execution_get_remains.result;
 }
 


@@ -293,7 +293,7 @@ e_smx_state_t SIMIX_req_host_execution_get_state(smx_action_t execution)
 
   req->call = REQ_HOST_EXECUTION_GET_STATE;
   req->host_execution_get_state.execution = execution;
 
   req->call = REQ_HOST_EXECUTION_GET_STATE;
   req->host_execution_get_state.execution = execution;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->host_execution_get_state.result;
 }
 
   return req->host_execution_get_state.result;
 }
 


@@ -314,7 +314,7 @@ void SIMIX_req_host_execution_set_priority(smx_action_t execution, double priori
   req->call = REQ_HOST_EXECUTION_SET_PRIORITY;
   req->host_execution_set_priority.execution = execution;
   req->host_execution_set_priority.priority = priority;
   req->call = REQ_HOST_EXECUTION_SET_PRIORITY;
   req->host_execution_set_priority.execution = execution;
   req->host_execution_set_priority.priority = priority;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

 }
 
 /**
 }
 
 /**


@@ -328,7 +328,7 @@ e_smx_state_t SIMIX_req_host_execution_wait(smx_action_t execution)
 
   req->call = REQ_HOST_EXECUTION_WAIT;
   req->host_execution_wait.execution = execution;
 
   req->call = REQ_HOST_EXECUTION_WAIT;
   req->host_execution_wait.execution = execution;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->host_execution_wait.result;
 }
 
   return req->host_execution_wait.result;
 }
 


@@ -365,7 +365,7 @@ void SIMIX_req_process_create(smx_process_t *process, const char *name,
   req->process_create.argc = argc;
   req->process_create.argv = argv;
   req->process_create.properties = properties;
   req->process_create.argc = argc;
   req->process_create.argv = argv;
   req->process_create.properties = properties;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

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


@@ -380,7 +380,7 @@ void SIMIX_req_process_kill(smx_process_t process)
 
   req->call = REQ_PROCESS_KILL;
   req->process_kill.process = process;
 
   req->call = REQ_PROCESS_KILL;
   req->process_kill.process = process;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

 }
 
 /** \brief Kills all SIMIX processes.
 }
 
 /** \brief Kills all SIMIX processes.


@@ -390,7 +390,7 @@ void SIMIX_req_process_killall(void)
   smx_req_t req = SIMIX_req_mine();
 
   req->call = REQ_PROCESS_KILLALL;
   smx_req_t req = SIMIX_req_mine();
 
   req->call = REQ_PROCESS_KILLALL;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

 }
 
 /** \brief Cleans up a SIMIX process.
 }
 
 /** \brief Cleans up a SIMIX process.


@@ -402,7 +402,7 @@ void SIMIX_req_process_cleanup(smx_process_t process)
 
   req->call = REQ_PROCESS_CLEANUP;
   req->process_cleanup.process = process;
 
   req->call = REQ_PROCESS_CLEANUP;
   req->process_cleanup.process = process;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

 }
 
 /**
 }
 
 /**


@@ -421,7 +421,7 @@ void SIMIX_req_process_change_host(smx_process_t process, smx_host_t dest)
   req->call = REQ_PROCESS_CHANGE_HOST;
   req->process_change_host.process = process;
   req->process_change_host.dest = dest;
   req->call = REQ_PROCESS_CHANGE_HOST;
   req->process_change_host.process = process;
   req->process_change_host.dest = dest;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

 }
 
 /**
 }
 
 /**


@@ -440,7 +440,7 @@ void SIMIX_req_process_suspend(smx_process_t process)
 
   req->call = REQ_PROCESS_SUSPEND;
   req->process_suspend.process = process;
 
   req->call = REQ_PROCESS_SUSPEND;
   req->process_suspend.process = process;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

 }
 
 /**
 }
 
 /**


@@ -457,7 +457,7 @@ void SIMIX_req_process_resume(smx_process_t process)
 
   req->call = REQ_PROCESS_RESUME;
   req->process_resume.process = process;
 
   req->call = REQ_PROCESS_RESUME;
   req->process_resume.process = process;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

 }
 
 /**
 }
 
 /**


@@ -470,29 +470,27 @@ int SIMIX_req_process_count(void)
   smx_req_t req = SIMIX_req_mine();
 
   req->call = REQ_PROCESS_COUNT;
   smx_req_t req = SIMIX_req_mine();
 
   req->call = REQ_PROCESS_COUNT;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->process_count.result;
 }
 
 /**
  * \brief Return the user data of a #smx_process_t.
   return req->process_count.result;
 }
 
 /**
  * \brief Return the user data of a #smx_process_t.

- *
- * This functions checks whether \a process is a valid pointer or not and return the user data associated to \a process if it is possible.
- * \param process SIMIX process
- * \return A void pointer to the user data
+ * \param process a SIMIX process
+ * \return the user data of this process

  */
 void* SIMIX_req_process_get_data(smx_process_t process)
 {
   if (process == SIMIX_process_self()) {
     /* avoid a request if this function is called by the process itself */
  */
 void* SIMIX_req_process_get_data(smx_process_t process)
 {
   if (process == SIMIX_process_self()) {
     /* avoid a request if this function is called by the process itself */

-    return SIMIX_process_self_get_data();
+    return SIMIX_process_get_data(process);

   }
 
   smx_req_t req = SIMIX_req_mine();
 
   req->call = REQ_PROCESS_GET_DATA;
   req->process_get_data.process = process;
   }
 
   smx_req_t req = SIMIX_req_mine();
 
   req->call = REQ_PROCESS_GET_DATA;
   req->process_get_data.process = process;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->process_get_data.result;
 }
 
   return req->process_get_data.result;
 }
 


@@ -507,7 +505,7 @@ void SIMIX_req_process_set_data(smx_process_t process, void *data)
 {
   if (process == SIMIX_process_self()) {
     /* avoid a request if this function is called by the process itself */
 {
   if (process == SIMIX_process_self()) {
     /* avoid a request if this function is called by the process itself */

-    SIMIX_process_self_set_data(data);
+    SIMIX_process_self_set_data(process, data);

   }
   else {
 
   }
   else {
 


@@ -516,7 +514,7 @@ void SIMIX_req_process_set_data(smx_process_t process, void *data)
     req->call = REQ_PROCESS_SET_DATA;
     req->process_set_data.process = process;
     req->process_set_data.data = data;
     req->call = REQ_PROCESS_SET_DATA;
     req->process_set_data.process = process;
     req->process_set_data.data = data;

-    SIMIX_request_push();
+    SIMIX_request_push(req->issuer);

   }
 }
 
   }
 }
 


@@ -533,7 +531,7 @@ smx_host_t SIMIX_req_process_get_host(smx_process_t process)
 
   req->call = REQ_PROCESS_GET_HOST;
   req->process_get_host.process = process;
 
   req->call = REQ_PROCESS_GET_HOST;
   req->process_get_host.process = process;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->process_get_host.result;
 }
 
   return req->process_get_host.result;
 }
 


@@ -555,7 +553,7 @@ const char* SIMIX_req_process_get_name(smx_process_t process)
 
   req->call = REQ_PROCESS_GET_NAME;
   req->process_get_name.process = process;
 
   req->call = REQ_PROCESS_GET_NAME;
   req->process_get_name.process = process;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->process_get_name.result;
 }
 
   return req->process_get_name.result;
 }
 


@@ -572,7 +570,7 @@ int SIMIX_req_process_is_suspended(smx_process_t process)
 
   req->call = REQ_PROCESS_IS_SUSPENDED;
   req->process_is_suspended.process = process;
 
   req->call = REQ_PROCESS_IS_SUSPENDED;
   req->process_is_suspended.process = process;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->process_is_suspended.result;
 }
 
   return req->process_is_suspended.result;
 }
 


@@ -587,7 +585,7 @@ xbt_dict_t SIMIX_req_process_get_properties(smx_process_t process)
 
   req->call = REQ_PROCESS_GET_PROPERTIES;
   req->process_get_properties.process = process;
 
   req->call = REQ_PROCESS_GET_PROPERTIES;
   req->process_get_properties.process = process;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->process_get_properties.result;
 }
 
   return req->process_get_properties.result;
 }
 


@@ -609,7 +607,7 @@ e_smx_state_t SIMIX_req_process_sleep(double duration)
 
   req->call = REQ_PROCESS_SLEEP;
   req->process_sleep.duration = duration;
 
   req->call = REQ_PROCESS_SLEEP;
   req->process_sleep.duration = duration;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->process_sleep.result;
 }
 
   return req->process_sleep.result;
 }
 


@@ -625,7 +623,7 @@ smx_rdv_t SIMIX_req_rdv_create(const char *name)
   req->call = REQ_RDV_CREATE;
   req->rdv_create.name = name;
 
   req->call = REQ_RDV_CREATE;
   req->rdv_create.name = name;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->rdv_create.result;
 }
 
   return req->rdv_create.result;
 }
 


@@ -641,7 +639,7 @@ void SIMIX_req_rdv_destroy(smx_rdv_t rdv)
   req->call = REQ_RDV_DESTROY;
   req->rdv_destroy.rdv = rdv;
 
   req->call = REQ_RDV_DESTROY;
   req->rdv_destroy.rdv = rdv;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

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


@@ -655,7 +653,7 @@ smx_rdv_t SIMIX_req_rdv_get_by_name(const char *name)
   smx_req_t req = SIMIX_req_mine();
   req->call = REQ_RDV_GEY_BY_NAME;
   req->rdv_get_by_name.name = name;
   smx_req_t req = SIMIX_req_mine();
   req->call = REQ_RDV_GEY_BY_NAME;
   req->rdv_get_by_name.name = name;

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->rdv_get_by_name.result;*/
 
   return SIMIX_rdv_get_by_name(name);
   return req->rdv_get_by_name.result;*/
 
   return SIMIX_rdv_get_by_name(name);


@@ -676,7 +674,7 @@ int SIMIX_req_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host)
   req->rdv_comm_count_by_host.rdv = rdv;
   req->rdv_comm_count_by_host.host = host;
 
   req->rdv_comm_count_by_host.rdv = rdv;
   req->rdv_comm_count_by_host.host = host;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->rdv_comm_count_by_host.result;
 }
 
   return req->rdv_comm_count_by_host.result;
 }
 


@@ -692,7 +690,7 @@ smx_action_t SIMIX_req_rdv_get_head(smx_rdv_t rdv)
   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();
+  SIMIX_request_push(req->issuer);

   return req->rdv_get_head.result;
 }
 
   return req->rdv_get_head.result;
 }
 


@@ -727,7 +725,7 @@ void SIMIX_req_comm_send(smx_rdv_t rdv, double task_size, double rate,
     req->comm_send.data = data;
     req->comm_send.timeout = timeout;
 
     req->comm_send.data = data;
     req->comm_send.timeout = timeout;
 

-    SIMIX_request_push();
+    SIMIX_request_push(req->issuer);

   }
 }
 
   }
 }
 


@@ -754,7 +752,7 @@ smx_action_t SIMIX_req_comm_isend(smx_rdv_t rdv, double task_size, double rate,
   req->comm_isend.data = data;
   req->comm_isend.detached = detached;
 
   req->comm_isend.data = data;
   req->comm_isend.detached = detached;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->comm_isend.result;
 }
 
   return req->comm_isend.result;
 }
 


@@ -781,7 +779,7 @@ void SIMIX_req_comm_recv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size,
     req->comm_recv.data = data;
     req->comm_recv.timeout = timeout;
 
     req->comm_recv.data = data;
     req->comm_recv.timeout = timeout;
 

-    SIMIX_request_push();
+    SIMIX_request_push(req->issuer);

   }
 }
 
   }
 }
 


@@ -799,7 +797,7 @@ smx_action_t SIMIX_req_comm_irecv(smx_rdv_t rdv, void *dst_buff, size_t * dst_bu
   req->comm_irecv.match_fun = match_fun;
   req->comm_irecv.data = data;
 
   req->comm_irecv.match_fun = match_fun;
   req->comm_irecv.data = data;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->comm_irecv.result;
 }
 
   return req->comm_irecv.result;
 }
 


@@ -815,7 +813,7 @@ void SIMIX_req_comm_destroy(smx_action_t comm)
   req->call = REQ_COMM_DESTROY;
   req->comm_destroy.comm = comm;
 
   req->call = REQ_COMM_DESTROY;
   req->comm_destroy.comm = comm;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   */
 }
 
   */
 }
 


@@ -826,7 +824,7 @@ void SIMIX_req_comm_cancel(smx_action_t comm)
   req->call = REQ_COMM_CANCEL;
   req->comm_cancel.comm = comm;
 
   req->call = REQ_COMM_CANCEL;
   req->comm_cancel.comm = comm;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

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


@@ -836,7 +834,7 @@ unsigned int SIMIX_req_comm_waitany(xbt_dynar_t comms)
   req->call = REQ_COMM_WAITANY;
   req->comm_waitany.comms = comms;
 
   req->call = REQ_COMM_WAITANY;
   req->comm_waitany.comms = comms;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->comm_waitany.result;
 }
 
   return req->comm_waitany.result;
 }
 


@@ -849,7 +847,7 @@ int SIMIX_req_comm_testany(xbt_dynar_t comms)
   req->call = REQ_COMM_TESTANY;
   req->comm_testany.comms = comms;
 
   req->call = REQ_COMM_TESTANY;
   req->comm_testany.comms = comms;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->comm_testany.result;
 }
 
   return req->comm_testany.result;
 }
 


@@ -863,7 +861,7 @@ void SIMIX_req_comm_wait(smx_action_t comm, double timeout)
   req->comm_wait.comm = comm;
   req->comm_wait.timeout = timeout;
 
   req->comm_wait.comm = comm;
   req->comm_wait.timeout = timeout;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

 }
 
 #ifdef HAVE_TRACING
 }
 
 #ifdef HAVE_TRACING


@@ -886,7 +884,7 @@ void SIMIX_req_set_category(smx_action_t action, const char *category)
   req->set_category.action = action;
   req->set_category.category = category;
 
   req->set_category.action = action;
   req->set_category.category = category;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

 }
 #endif
 
 }
 #endif
 


@@ -897,7 +895,7 @@ int SIMIX_req_comm_test(smx_action_t comm)
   req->call = REQ_COMM_TEST;
   req->comm_test.comm = comm;
 
   req->call = REQ_COMM_TEST;
   req->comm_test.comm = comm;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->comm_test.result;
 }
 
   return req->comm_test.result;
 }
 


@@ -908,7 +906,7 @@ double SIMIX_req_comm_get_remains(smx_action_t comm)
   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();
+  SIMIX_request_push(req->issuer);

   return req->comm_get_remains.result;
 }
 
   return req->comm_get_remains.result;
 }
 


@@ -919,7 +917,7 @@ e_smx_state_t SIMIX_req_comm_get_state(smx_action_t comm)
   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();
+  SIMIX_request_push(req->issuer);

   return req->comm_get_state.result;
 }
 
   return req->comm_get_state.result;
 }
 


@@ -930,7 +928,7 @@ void *SIMIX_req_comm_get_src_data(smx_action_t comm)
   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();
+  SIMIX_request_push(req->issuer);

   return req->comm_get_src_data.result;
 }
 
   return req->comm_get_src_data.result;
 }
 


@@ -941,7 +939,7 @@ void *SIMIX_req_comm_get_dst_data(smx_action_t comm)
   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();
+  SIMIX_request_push(req->issuer);

   return req->comm_get_dst_data.result;
 }
 
   return req->comm_get_dst_data.result;
 }
 


@@ -952,7 +950,7 @@ smx_process_t SIMIX_req_comm_get_src_proc(smx_action_t comm)
   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();
+  SIMIX_request_push(req->issuer);

   return req->comm_get_src_proc.result;
 }
 
   return req->comm_get_src_proc.result;
 }
 


@@ -963,7 +961,7 @@ smx_process_t SIMIX_req_comm_get_dst_proc(smx_action_t comm)
   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();
+  SIMIX_request_push(req->issuer);

   return req->comm_get_dst_proc.result;
 }
 
   return req->comm_get_dst_proc.result;
 }
 


@@ -975,7 +973,7 @@ int SIMIX_req_comm_is_latency_bounded(smx_action_t comm)
   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();
+  SIMIX_request_push(req->issuer);

   return req->comm_is_latency_bounded.result;
 }
 #endif
   return req->comm_is_latency_bounded.result;
 }
 #endif


@@ -986,7 +984,7 @@ smx_mutex_t SIMIX_req_mutex_init(void)
 
   req->call = REQ_MUTEX_INIT;
 
 
   req->call = REQ_MUTEX_INIT;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->mutex_init.result;
 }
 
   return req->mutex_init.result;
 }
 


@@ -997,7 +995,7 @@ void SIMIX_req_mutex_destroy(smx_mutex_t mutex)
   req->call = REQ_MUTEX_DESTROY;
   req->mutex_destroy.mutex = mutex;
 
   req->call = REQ_MUTEX_DESTROY;
   req->mutex_destroy.mutex = mutex;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

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


@@ -1007,7 +1005,7 @@ void SIMIX_req_mutex_lock(smx_mutex_t mutex)
   req->call = REQ_MUTEX_LOCK;
   req->mutex_lock.mutex = mutex;
 
   req->call = REQ_MUTEX_LOCK;
   req->mutex_lock.mutex = mutex;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

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


@@ -1017,7 +1015,7 @@ int SIMIX_req_mutex_trylock(smx_mutex_t mutex)
   req->call = REQ_MUTEX_TRYLOCK;
   req->mutex_trylock.mutex = mutex;
 
   req->call = REQ_MUTEX_TRYLOCK;
   req->mutex_trylock.mutex = mutex;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->mutex_trylock.result;
 }
 
   return req->mutex_trylock.result;
 }
 


@@ -1028,7 +1026,7 @@ void SIMIX_req_mutex_unlock(smx_mutex_t mutex)
   req->call = REQ_MUTEX_UNLOCK;
   req->mutex_unlock.mutex = mutex;
 
   req->call = REQ_MUTEX_UNLOCK;
   req->mutex_unlock.mutex = mutex;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

 }
 
 
 }
 
 


@@ -1038,7 +1036,7 @@ smx_cond_t SIMIX_req_cond_init(void)
 
   req->call = REQ_COND_INIT;
 
 
   req->call = REQ_COND_INIT;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->cond_init.result;
 }
 
   return req->cond_init.result;
 }
 


@@ -1049,7 +1047,7 @@ void SIMIX_req_cond_destroy(smx_cond_t cond)
   req->call = REQ_COND_DESTROY;
   req->cond_destroy.cond = cond;
 
   req->call = REQ_COND_DESTROY;
   req->cond_destroy.cond = cond;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

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


@@ -1059,7 +1057,7 @@ void SIMIX_req_cond_signal(smx_cond_t cond)
   req->call = REQ_COND_SIGNAL;
   req->cond_signal.cond = cond;
 
   req->call = REQ_COND_SIGNAL;
   req->cond_signal.cond = cond;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

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


@@ -1070,7 +1068,7 @@ void SIMIX_req_cond_wait(smx_cond_t cond, smx_mutex_t mutex)
   req->cond_wait.cond = cond;
   req->cond_wait.mutex = mutex;
 
   req->cond_wait.cond = cond;
   req->cond_wait.mutex = mutex;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

 }
 
 void SIMIX_req_cond_wait_timeout(smx_cond_t cond,
 }
 
 void SIMIX_req_cond_wait_timeout(smx_cond_t cond,


@@ -1086,7 +1084,7 @@ void SIMIX_req_cond_wait_timeout(smx_cond_t cond,
   req->cond_wait_timeout.mutex = mutex;
   req->cond_wait_timeout.timeout = timeout;
 
   req->cond_wait_timeout.mutex = mutex;
   req->cond_wait_timeout.timeout = timeout;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

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


@@ -1096,7 +1094,7 @@ void SIMIX_req_cond_broadcast(smx_cond_t cond)
   req->call = REQ_COND_BROADCAST;
   req->cond_broadcast.cond = cond;
 
   req->call = REQ_COND_BROADCAST;
   req->cond_broadcast.cond = cond;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

 }
 
 
 }
 
 


@@ -1107,7 +1105,7 @@ smx_sem_t SIMIX_req_sem_init(int capacity)
   req->call = REQ_SEM_INIT;
   req->sem_init.capacity = capacity;
 
   req->call = REQ_SEM_INIT;
   req->sem_init.capacity = capacity;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

   return req->sem_init.result;
 }
 
   return req->sem_init.result;
 }
 


@@ -1118,7 +1116,7 @@ void SIMIX_req_sem_destroy(smx_sem_t sem)
   req->call = REQ_SEM_DESTROY;
   req->sem_destroy.sem = sem;
 
   req->call = REQ_SEM_DESTROY;
   req->sem_destroy.sem = sem;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

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


@@ -1128,7 +1126,7 @@ void SIMIX_req_sem_release(smx_sem_t sem)
   req->call = REQ_SEM_RELEASE;
   req->sem_release.sem = sem;
 
   req->call = REQ_SEM_RELEASE;
   req->sem_release.sem = sem;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

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


@@ -1138,7 +1136,7 @@ int SIMIX_req_sem_would_block(smx_sem_t sem)
   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();
+  SIMIX_request_push(req->issuer);

   return req->sem_would_block.result;
 }
 
   return req->sem_would_block.result;
 }
 


@@ -1149,7 +1147,7 @@ void SIMIX_req_sem_acquire(smx_sem_t sem)
   req->call = REQ_SEM_ACQUIRE;
   req->sem_acquire.sem = sem;
 
   req->call = REQ_SEM_ACQUIRE;
   req->sem_acquire.sem = sem;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

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


@@ -1162,7 +1160,7 @@ void SIMIX_req_sem_acquire_timeout(smx_sem_t sem, double timeout)
   req->sem_acquire_timeout.sem = sem;
   req->sem_acquire_timeout.timeout = timeout;
 
   req->sem_acquire_timeout.sem = sem;
   req->sem_acquire_timeout.timeout = timeout;
 

-  SIMIX_request_push();
+  SIMIX_request_push(req->issuer);

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


@@ -1172,7 +1170,7 @@ int SIMIX_req_sem_get_capacity(smx_sem_t sem)
   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();
+  SIMIX_request_push(req->issuer);

   return req->sem_get_capacity.result;
 }
 /* ************************************************************************** */
   return req->sem_get_capacity.result;
 }
 /* ************************************************************************** */

diff --git a/src/smpi/smpi_global.c b/src/smpi/smpi_global.c
index 1b98966..ade00ae 100644 (file)
--- a/src/smpi/smpi_global.c
+++ b/src/smpi/smpi_global.c
@@ -105,7 +105,7 @@ int smpi_global_size(void) {
 
 smpi_process_data_t smpi_process_data(void)
 {
 
 smpi_process_data_t smpi_process_data(void)
 {

-  return SIMIX_process_self_get_data();
+  return SIMIX_process_self_get_data(SIMIX_process_self());

 }
 
 smpi_process_data_t smpi_process_remote_data(int index)
 }
 
 smpi_process_data_t smpi_process_remote_data(int index)

diff --git a/src/xbt/xbt_sg_synchro.c b/src/xbt/xbt_sg_synchro.c
index f95d16a..df45b81 100644 (file)
--- a/src/xbt/xbt_sg_synchro.c
+++ b/src/xbt/xbt_sg_synchro.c
@@ -36,9 +36,10 @@ typedef struct s_xbt_thread_ {
 
 static int xbt_thread_create_wrapper(int argc, char *argv[])
 {
 
 static int xbt_thread_create_wrapper(int argc, char *argv[])
 {

+  smx_process_t self = SIMIX_process_self();

   xbt_thread_t t =
   xbt_thread_t t =

-      (xbt_thread_t) SIMIX_process_self_get_data();
-  SIMIX_req_process_set_data(SIMIX_process_self(), t->father_data);
+      (xbt_thread_t) SIMIX_process_self_get_data(self);
+  SIMIX_req_process_set_data(self, t->father_data);

   t->code(t->userparam);
   if (t->joinable) {
     t->done = 1;
   t->code(t->userparam);
   if (t->joinable) {
     t->done = 1;


@@ -61,7 +62,7 @@ xbt_thread_t xbt_thread_create(const char *name, void_f_pvoid_t code,
   res->name = xbt_strdup(name);
   res->userparam = param;
   res->code = code;
   res->name = xbt_strdup(name);
   res->userparam = param;
   res->code = code;

-  res->father_data = SIMIX_process_self_get_data();
+  res->father_data = SIMIX_process_self_get_data(SIMIX_process_self());

   /*   char*name = bprintf("%s#%p",SIMIX_process_self_get_name(), param); */
   SIMIX_req_process_create(&res->s_process, name,
                            xbt_thread_create_wrapper, res,
   /*   char*name = bprintf("%s#%p",SIMIX_process_self_get_name(), param); */
   SIMIX_req_process_create(&res->s_process, name,
                            xbt_thread_create_wrapper, res,


@@ -118,12 +119,12 @@ void xbt_thread_exit()
 
 xbt_thread_t xbt_thread_self(void)
 {
 
 xbt_thread_t xbt_thread_self(void)
 {

-  return SIMIX_process_self_get_data();
+  return SIMIX_process_self_get_data(SIMIX_process_self());

 }
 
 void xbt_thread_yield(void)
 {
 }
 
 void xbt_thread_yield(void)
 {

-  SIMIX_process_yield();
+  SIMIX_process_yield(SIMIX_process_self());

 }
 
 /****** mutex related functions ******/
 }
 
 /****** mutex related functions ******/