Use msg_process_t instead of m_process_t

diff --git a/examples/msg/masterslave/masterslave_kill.c b/examples/msg/masterslave/masterslave_kill.c
index ae4a14d..01a0e85 100644 (file)
--- a/examples/msg/masterslave/masterslave_kill.c
+++ b/examples/msg/masterslave/masterslave_kill.c
@@ -26,7 +26,7 @@ static int slave(int argc, char *argv[])
 
 static int master(int argc, char *argv[])
 {
 
 static int master(int argc, char *argv[])
 {

-  m_process_t bob = NULL;
+  msg_process_t bob = NULL;

 
   XBT_INFO("Hello!");
   bob = MSG_process_create("slave", slave, NULL, MSG_get_host_by_name("bob"));
 
   XBT_INFO("Hello!");
   bob = MSG_process_create("slave", slave, NULL, MSG_get_host_by_name("bob"));

diff --git a/examples/msg/migration/migration.c b/examples/msg/migration/migration.c
index eb3c78a..4cf0400 100644 (file)
--- a/examples/msg/migration/migration.c
+++ b/examples/msg/migration/migration.c
@@ -21,7 +21,7 @@ XBT_LOG_NEW_DEFAULT_CATEGORY(msg_test,
 
 xbt_mutex_t mutex = NULL;
 xbt_cond_t cond = NULL;
 
 xbt_mutex_t mutex = NULL;
 xbt_cond_t cond = NULL;

-static m_process_t process_to_migrate = NULL;
+static msg_process_t process_to_migrate = NULL;

 
 /** The guy we will move from host to host. It move alone and then is moved by policeman back  */
 static int emigrant(int argc, char *argv[])
 
 /** The guy we will move from host to host. It move alone and then is moved by policeman back  */
 static int emigrant(int argc, char *argv[])

diff --git a/examples/msg/suspend/suspend.c b/examples/msg/suspend/suspend.c
index 1c794a5..60fe071 100644 (file)
--- a/examples/msg/suspend/suspend.c
+++ b/examples/msg/suspend/suspend.c
@@ -31,7 +31,7 @@ static int lazy_guy(int argc, char *argv[])
     resumes it 10 seconds later. */
 static int dream_master(int argc, char *argv[])
 {
     resumes it 10 seconds later. */
 static int dream_master(int argc, char *argv[])
 {

-  m_process_t lazy = NULL;
+  msg_process_t lazy = NULL;

 
   XBT_INFO("Let's create a lazy guy.");
   lazy = MSG_process_create("Lazy", lazy_guy, NULL, MSG_host_self());
 
   XBT_INFO("Let's create a lazy guy.");
   lazy = MSG_process_create("Lazy", lazy_guy, NULL, MSG_host_self());

diff --git a/include/msg/datatypes.h b/include/msg/datatypes.h
index 4ce5731..afd2441 100644 (file)
--- a/include/msg/datatypes.h
+++ b/include/msg/datatypes.h
@@ -139,7 +139,10 @@ typedef struct msg_comm *msg_comm_t;
     structure, but always use the provided API to interact with
     processes.
  */
     structure, but always use the provided API to interact with
     processes.
  */

-typedef struct s_smx_process *m_process_t;
+typedef struct s_smx_process *msg_process_t;
+
+/* Compatibility typedefs */
+typedef msg_process_t m_process_t;

 
 #ifdef MSG_USE_DEPRECATED
 typedef int m_channel_t;
 
 #ifdef MSG_USE_DEPRECATED
 typedef int m_channel_t;

diff --git a/include/msg/msg.h b/include/msg/msg.h
index 4d25696..c0b5c6c 100644 (file)
--- a/include/msg/msg.h
+++ b/include/msg/msg.h
@@ -107,16 +107,16 @@ XBT_PUBLIC(m_host_t) MSG_get_host_by_name(const char *name);
 XBT_PUBLIC(xbt_dynar_t) MSG_hosts_as_dynar(void);
 
 /************************** Process handling *********************************/
 XBT_PUBLIC(xbt_dynar_t) MSG_hosts_as_dynar(void);
 
 /************************** Process handling *********************************/

-XBT_PUBLIC(m_process_t) MSG_process_create(const char *name,
+XBT_PUBLIC(msg_process_t) MSG_process_create(const char *name,

                                            xbt_main_func_t code,
                                            void *data, m_host_t host);
                                            xbt_main_func_t code,
                                            void *data, m_host_t host);

-XBT_PUBLIC(m_process_t) MSG_process_create_with_arguments(const char *name,
+XBT_PUBLIC(msg_process_t) MSG_process_create_with_arguments(const char *name,

                                                           xbt_main_func_t
                                                           code, void *data,
                                                           m_host_t host,
                                                           int argc,
                                                           char **argv);
                                                           xbt_main_func_t
                                                           code, void *data,
                                                           m_host_t host,
                                                           int argc,
                                                           char **argv);

-XBT_PUBLIC(m_process_t) MSG_process_create_with_environment(const char
+XBT_PUBLIC(msg_process_t) MSG_process_create_with_environment(const char

                                                             *name,
                                                             xbt_main_func_t
                                                             code,
                                                             *name,
                                                             xbt_main_func_t
                                                             code,


@@ -126,37 +126,37 @@ XBT_PUBLIC(m_process_t) MSG_process_create_with_environment(const char
                                                             char **argv,
                                                             xbt_dict_t
                                                             properties);
                                                             char **argv,
                                                             xbt_dict_t
                                                             properties);

-XBT_PUBLIC(void) MSG_process_kill(m_process_t process);
+XBT_PUBLIC(void) MSG_process_kill(msg_process_t process);

 XBT_PUBLIC(int) MSG_process_killall(int reset_PIDs);
 
 XBT_PUBLIC(int) MSG_process_killall(int reset_PIDs);
 

-XBT_PUBLIC(MSG_error_t) MSG_process_migrate(m_process_t process, m_host_t host);
+XBT_PUBLIC(MSG_error_t) MSG_process_migrate(msg_process_t process, m_host_t host);

 
 

-XBT_PUBLIC(void *) MSG_process_get_data(m_process_t process);
-XBT_PUBLIC(MSG_error_t) MSG_process_set_data(m_process_t process,
+XBT_PUBLIC(void *) MSG_process_get_data(msg_process_t process);
+XBT_PUBLIC(MSG_error_t) MSG_process_set_data(msg_process_t process,

                                              void *data);
 XBT_PUBLIC(void) MSG_process_set_data_cleanup(void_f_pvoid_t data_cleanup);
                                              void *data);
 XBT_PUBLIC(void) MSG_process_set_data_cleanup(void_f_pvoid_t data_cleanup);

-XBT_PUBLIC(m_host_t) MSG_process_get_host(m_process_t process);
-XBT_PUBLIC(m_process_t) MSG_process_from_PID(int PID);
-XBT_PUBLIC(int) MSG_process_get_PID(m_process_t process);
-XBT_PUBLIC(int) MSG_process_get_PPID(m_process_t process);
-XBT_PUBLIC(const char *) MSG_process_get_name(m_process_t process);
+XBT_PUBLIC(m_host_t) MSG_process_get_host(msg_process_t process);
+XBT_PUBLIC(msg_process_t) MSG_process_from_PID(int PID);
+XBT_PUBLIC(int) MSG_process_get_PID(msg_process_t process);
+XBT_PUBLIC(int) MSG_process_get_PPID(msg_process_t process);
+XBT_PUBLIC(const char *) MSG_process_get_name(msg_process_t process);

 XBT_PUBLIC(int) MSG_process_self_PID(void);
 XBT_PUBLIC(int) MSG_process_self_PPID(void);
 XBT_PUBLIC(int) MSG_process_self_PID(void);
 XBT_PUBLIC(int) MSG_process_self_PPID(void);

-XBT_PUBLIC(m_process_t) MSG_process_self(void);
+XBT_PUBLIC(msg_process_t) MSG_process_self(void);

 XBT_PUBLIC(xbt_dynar_t) MSG_processes_as_dynar(void);
 XBT_PUBLIC(xbt_dynar_t) MSG_processes_as_dynar(void);

-XBT_PUBLIC(MSG_error_t) MSG_process_set_kill_time(m_process_t process, double kill_time);
+XBT_PUBLIC(MSG_error_t) MSG_process_set_kill_time(msg_process_t process, double kill_time);

 
 /*property handlers*/
 
 /*property handlers*/

-XBT_PUBLIC(xbt_dict_t) MSG_process_get_properties(m_process_t process);
-XBT_PUBLIC(const char *) MSG_process_get_property_value(m_process_t
+XBT_PUBLIC(xbt_dict_t) MSG_process_get_properties(msg_process_t process);
+XBT_PUBLIC(const char *) MSG_process_get_property_value(msg_process_t

                                                         process,
                                                         const char *name);
 
                                                         process,
                                                         const char *name);
 

-XBT_PUBLIC(MSG_error_t) MSG_process_suspend(m_process_t process);
-XBT_PUBLIC(MSG_error_t) MSG_process_resume(m_process_t process);
-XBT_PUBLIC(int) MSG_process_is_suspended(m_process_t process);
+XBT_PUBLIC(MSG_error_t) MSG_process_suspend(msg_process_t process);
+XBT_PUBLIC(MSG_error_t) MSG_process_resume(msg_process_t process);
+XBT_PUBLIC(int) MSG_process_is_suspended(msg_process_t process);

 XBT_PUBLIC(void) MSG_process_on_exit(int_f_pvoid_t fun, void *data);
 XBT_PUBLIC(void) MSG_process_on_exit(int_f_pvoid_t fun, void *data);

-XBT_PUBLIC(void) MSG_process_auto_restart_set(m_process_t process, int auto_restart);
+XBT_PUBLIC(void) MSG_process_auto_restart_set(msg_process_t process, int auto_restart);

 
 /************************** Task handling ************************************/
 XBT_PUBLIC(m_task_t) MSG_task_create(const char *name,
 
 /************************** Task handling ************************************/
 XBT_PUBLIC(m_task_t) MSG_task_create(const char *name,


@@ -175,8 +175,8 @@ XBT_PUBLIC(m_task_t) MSG_parallel_task_create(const char *name,
 XBT_PUBLIC(void *) MSG_task_get_data(m_task_t task);
 XBT_PUBLIC(void) MSG_task_set_data(m_task_t task, void *data);
 XBT_PUBLIC(void) MSG_task_set_copy_callback(void (*callback) (
 XBT_PUBLIC(void *) MSG_task_get_data(m_task_t task);
 XBT_PUBLIC(void) MSG_task_set_data(m_task_t task, void *data);
 XBT_PUBLIC(void) MSG_task_set_copy_callback(void (*callback) (

-    m_task_t task, m_process_t src, m_process_t dst));
-XBT_PUBLIC(m_process_t) MSG_task_get_sender(m_task_t task);
+    m_task_t task, msg_process_t src, msg_process_t dst));
+XBT_PUBLIC(msg_process_t) MSG_task_get_sender(m_task_t task);

 XBT_PUBLIC(m_host_t) MSG_task_get_source(m_task_t task);
 XBT_PUBLIC(const char *) MSG_task_get_name(m_task_t task);
 XBT_PUBLIC(void) MSG_task_set_name(m_task_t task, const char *name);
 XBT_PUBLIC(m_host_t) MSG_task_get_source(m_task_t task);
 XBT_PUBLIC(const char *) MSG_task_get_name(m_task_t task);
 XBT_PUBLIC(void) MSG_task_set_name(m_task_t task, const char *name);


@@ -323,8 +323,8 @@ XBT_PUBLIC(msg_vm_t) MSG_vm_start(m_host_t location, int coreAmount);
 XBT_PUBLIC(int) MSG_vm_is_suspended(msg_vm_t);
 XBT_PUBLIC(int) MSG_vm_is_running(msg_vm_t);
 
 XBT_PUBLIC(int) MSG_vm_is_suspended(msg_vm_t);
 XBT_PUBLIC(int) MSG_vm_is_running(msg_vm_t);
 

-XBT_PUBLIC(void) MSG_vm_bind(msg_vm_t vm, m_process_t process);
-XBT_PUBLIC(void) MSG_vm_unbind(msg_vm_t vm, m_process_t process); // simple wrapper over process_kill
+XBT_PUBLIC(void) MSG_vm_bind(msg_vm_t vm, msg_process_t process);
+XBT_PUBLIC(void) MSG_vm_unbind(msg_vm_t vm, msg_process_t process); // simple wrapper over process_kill

 
 XBT_PUBLIC(void) MSG_vm_migrate(msg_vm_t vm, m_host_t destination);
 
 
 XBT_PUBLIC(void) MSG_vm_migrate(msg_vm_t vm, m_host_t destination);
 


@@ -363,7 +363,7 @@ xbt_dynar_t<msg_vm_t> MSG_vm_get_list_from_hosts(msg_dynar_t<msg_host_t>)
 
 /* ****************************************************************************************** */
 /* Used only by the bindings -- unclean pimple, please ignore if you're not writing a binding */
 
 /* ****************************************************************************************** */
 /* Used only by the bindings -- unclean pimple, please ignore if you're not writing a binding */

-XBT_PUBLIC(smx_context_t) MSG_process_get_smx_ctx(m_process_t process);
+XBT_PUBLIC(smx_context_t) MSG_process_get_smx_ctx(msg_process_t process);

 
 SG_END_DECL()
 #endif
 
 SG_END_DECL()
 #endif

diff --git a/src/bindings/lua/lua_task.c b/src/bindings/lua/lua_task.c
index cfdf114..1326b2a 100644 (file)
--- a/src/bindings/lua/lua_task.c
+++ b/src/bindings/lua/lua_task.c
@@ -192,8 +192,8 @@ void sglua_task_unregister(lua_State* L, m_task_t task) {
  * \param src_process the sender
  * \param dst_process the receiver
  */
  * \param src_process the sender
  * \param dst_process the receiver
  */

-static void task_copy_callback(m_task_t task, m_process_t src_process,
-    m_process_t dst_process) {
+static void task_copy_callback(m_task_t task, msg_process_t src_process,
+    msg_process_t dst_process) {

 
   lua_State* src = MSG_process_get_data(src_process);
   lua_State* dst = MSG_process_get_data(dst_process);
 
   lua_State* src = MSG_process_get_data(src_process);
   lua_State* dst = MSG_process_get_data(dst_process);

diff --git a/src/instr/instr_msg_process.c b/src/instr/instr_msg_process.c
index c1a8154..e101491 100644 (file)
--- a/src/instr/instr_msg_process.c
+++ b/src/instr/instr_msg_process.c
@@ -10,7 +10,7 @@
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY (instr_msg_process, instr, "MSG process");
 
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY (instr_msg_process, instr, "MSG process");
 

-char *instr_process_id (m_process_t proc, char *str, int len)
+char *instr_process_id (msg_process_t proc, char *str, int len)

 {
   return instr_process_id_2 (proc->name, proc->pid, str, len);//MSG_process_get_name(proc), MSG_process_get_PID(proc), str, len);
 }
 {
   return instr_process_id_2 (proc->name, proc->pid, str, len);//MSG_process_get_name(proc), MSG_process_get_PID(proc), str, len);
 }


@@ -22,9 +22,9 @@ char *instr_process_id_2 (const char *process_name, int process_pid, char *str,
 }
 
 /*
 }
 
 /*

- * Instrumentation functions to trace MSG processes (m_process_t)
+ * Instrumentation functions to trace MSG processes (msg_process_t)

  */
  */

-void TRACE_msg_process_change_host(m_process_t process, m_host_t old_host, m_host_t new_host)
+void TRACE_msg_process_change_host(msg_process_t process, m_host_t old_host, m_host_t new_host)

 {
   if (TRACE_msg_process_is_enabled()){
     static long long int counter = 0;
 {
   if (TRACE_msg_process_is_enabled()){
     static long long int counter = 0;


@@ -65,7 +65,7 @@ void TRACE_msg_process_create (const char *process_name, int process_pid, m_host
   }
 }
 
   }
 }
 

-void TRACE_msg_process_kill(m_process_t process)
+void TRACE_msg_process_kill(msg_process_t process)

 {
   if (TRACE_msg_process_is_enabled()){
     int len = INSTR_DEFAULT_STR_SIZE;
 {
   if (TRACE_msg_process_is_enabled()){
     int len = INSTR_DEFAULT_STR_SIZE;


@@ -76,7 +76,7 @@ void TRACE_msg_process_kill(m_process_t process)
   }
 }
 
   }
 }
 

-void TRACE_msg_process_suspend(m_process_t process)
+void TRACE_msg_process_suspend(msg_process_t process)

 {
   if (TRACE_msg_process_is_enabled()){
     int len = INSTR_DEFAULT_STR_SIZE;
 {
   if (TRACE_msg_process_is_enabled()){
     int len = INSTR_DEFAULT_STR_SIZE;


@@ -89,7 +89,7 @@ void TRACE_msg_process_suspend(m_process_t process)
   }
 }
 
   }
 }
 

-void TRACE_msg_process_resume(m_process_t process)
+void TRACE_msg_process_resume(msg_process_t process)

 {
   if (TRACE_msg_process_is_enabled()){
     int len = INSTR_DEFAULT_STR_SIZE;
 {
   if (TRACE_msg_process_is_enabled()){
     int len = INSTR_DEFAULT_STR_SIZE;


@@ -101,7 +101,7 @@ void TRACE_msg_process_resume(m_process_t process)
   }
 }
 
   }
 }
 

-void TRACE_msg_process_sleep_in(m_process_t process)
+void TRACE_msg_process_sleep_in(msg_process_t process)

 {
   if (TRACE_msg_process_is_enabled()){
     int len = INSTR_DEFAULT_STR_SIZE;
 {
   if (TRACE_msg_process_is_enabled()){
     int len = INSTR_DEFAULT_STR_SIZE;


@@ -114,7 +114,7 @@ void TRACE_msg_process_sleep_in(m_process_t process)
   }
 }
 
   }
 }
 

-void TRACE_msg_process_sleep_out(m_process_t process)
+void TRACE_msg_process_sleep_out(msg_process_t process)

 {
   if (TRACE_msg_process_is_enabled()){
     int len = INSTR_DEFAULT_STR_SIZE;
 {
   if (TRACE_msg_process_is_enabled()){
     int len = INSTR_DEFAULT_STR_SIZE;


@@ -126,7 +126,7 @@ void TRACE_msg_process_sleep_out(m_process_t process)
   }
 }
 
   }
 }
 

-void TRACE_msg_process_end(m_process_t process)
+void TRACE_msg_process_end(msg_process_t process)

 {
   if (TRACE_msg_process_is_enabled()) {
     int len = INSTR_DEFAULT_STR_SIZE;
 {
   if (TRACE_msg_process_is_enabled()) {
     int len = INSTR_DEFAULT_STR_SIZE;

diff --git a/src/instr/instr_private.h b/src/instr/instr_private.h
index 49997e5..ba347a5 100644 (file)
--- a/src/instr/instr_private.h
+++ b/src/instr/instr_private.h
@@ -115,17 +115,17 @@ int TRACE_msg_task_put_start(m_task_t task);    //returns TRUE if the task_put_e
 void TRACE_msg_task_put_end(void);
 
 /* declaration of instrumentation functions from msg_process_instr.c */
 void TRACE_msg_task_put_end(void);
 
 /* declaration of instrumentation functions from msg_process_instr.c */

-char *instr_process_id (m_process_t proc, char *str, int len);
+char *instr_process_id (msg_process_t proc, char *str, int len);

 char *instr_process_id_2 (const char *process_name, int process_pid, char *str, int len);
 char *instr_process_id_2 (const char *process_name, int process_pid, char *str, int len);

-void TRACE_msg_process_change_host(m_process_t process, m_host_t old_host,
+void TRACE_msg_process_change_host(msg_process_t process, m_host_t old_host,

                                    m_host_t new_host);
 void TRACE_msg_process_create (const char *process_name, int process_pid, m_host_t host);
                                    m_host_t new_host);
 void TRACE_msg_process_create (const char *process_name, int process_pid, m_host_t host);

-void TRACE_msg_process_kill(m_process_t process);
-void TRACE_msg_process_suspend(m_process_t process);
-void TRACE_msg_process_resume(m_process_t process);
-void TRACE_msg_process_sleep_in(m_process_t process);   //called from msg/gos.c
-void TRACE_msg_process_sleep_out(m_process_t process);
-void TRACE_msg_process_end(m_process_t process);
+void TRACE_msg_process_kill(msg_process_t process);
+void TRACE_msg_process_suspend(msg_process_t process);
+void TRACE_msg_process_resume(msg_process_t process);
+void TRACE_msg_process_sleep_in(msg_process_t process);   //called from msg/gos.c
+void TRACE_msg_process_sleep_out(msg_process_t process);
+void TRACE_msg_process_end(msg_process_t process);

 
 /* from surf_instr.c */
 void TRACE_surf_alloc(void);
 
 /* from surf_instr.c */
 void TRACE_surf_alloc(void);

diff --git a/src/msg/msg_gos.c b/src/msg/msg_gos.c
index 833c1a6..a5839c3 100644 (file)
--- a/src/msg/msg_gos.c
+++ b/src/msg/msg_gos.c
@@ -38,7 +38,7 @@ MSG_error_t MSG_parallel_task_execute(m_task_t task)
 {
   xbt_ex_t e;
   simdata_task_t simdata = task->simdata;
 {
   xbt_ex_t e;
   simdata_task_t simdata = task->simdata;

-  m_process_t self = SIMIX_process_self();
+  msg_process_t self = SIMIX_process_self();

   simdata_process_t p_simdata = SIMIX_process_self_get_data(self);
   e_smx_state_t comp_state;
   MSG_error_t status = MSG_OK;
   simdata_process_t p_simdata = SIMIX_process_self_get_data(self);
   e_smx_state_t comp_state;
   MSG_error_t status = MSG_OK;


@@ -126,7 +126,7 @@ MSG_error_t MSG_parallel_task_execute(m_task_t task)
 MSG_error_t MSG_process_sleep(double nb_sec)
 {
   MSG_error_t status = MSG_OK;
 MSG_error_t MSG_process_sleep(double nb_sec)
 {
   MSG_error_t status = MSG_OK;

-  /*m_process_t proc = MSG_process_self();*/
+  /*msg_process_t proc = MSG_process_self();*/

 
 #ifdef HAVE_TRACING
   TRACE_msg_process_sleep_in(MSG_process_self());
 
 #ifdef HAVE_TRACING
   TRACE_msg_process_sleep_in(MSG_process_self());


@@ -291,7 +291,7 @@ XBT_INLINE msg_comm_t MSG_task_isend_with_matching(m_task_t task, const char *al
     void *match_data)
 {
   simdata_task_t t_simdata = NULL;
     void *match_data)
 {
   simdata_task_t t_simdata = NULL;

-  m_process_t process = MSG_process_self();
+  msg_process_t process = MSG_process_self();

   msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias);
 
   /* FIXME: these functions are not traceable */
   msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias);
 
   /* FIXME: these functions are not traceable */


@@ -341,7 +341,7 @@ XBT_INLINE msg_comm_t MSG_task_isend_with_matching(m_task_t task, const char *al
 void MSG_task_dsend(m_task_t task, const char *alias, void_f_pvoid_t cleanup)
 {
   simdata_task_t t_simdata = NULL;
 void MSG_task_dsend(m_task_t task, const char *alias, void_f_pvoid_t cleanup)
 {
   simdata_task_t t_simdata = NULL;

-  m_process_t process = MSG_process_self();
+  msg_process_t process = MSG_process_self();

   msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias);
 
   /* FIXME: these functions are not traceable */
   msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias);
 
   /* FIXME: these functions are not traceable */

diff --git a/src/msg/msg_mailbox.c b/src/msg/msg_mailbox.c
index 44e062e..dfd97d7 100644 (file)
--- a/src/msg/msg_mailbox.c
+++ b/src/msg/msg_mailbox.c
@@ -115,7 +115,7 @@ MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, m_task_t task,
   xbt_ex_t e;
   MSG_error_t ret = MSG_OK;
   simdata_task_t t_simdata = NULL;
   xbt_ex_t e;
   MSG_error_t ret = MSG_OK;
   simdata_task_t t_simdata = NULL;

-  m_process_t process = MSG_process_self();
+  msg_process_t process = MSG_process_self();

   simdata_process_t p_simdata = SIMIX_process_self_get_data(process);
 
 #ifdef HAVE_TRACING
   simdata_process_t p_simdata = SIMIX_process_self_get_data(process);
 
 #ifdef HAVE_TRACING

diff --git a/src/msg/msg_private.h b/src/msg/msg_private.h
index b9aaf07..16e1281 100644 (file)
--- a/src/msg/msg_private.h
+++ b/src/msg/msg_private.h
@@ -28,8 +28,8 @@ typedef struct simdata_task {
   smx_action_t comm;            /* SIMIX modeling of communication */
   double message_size;          /* Data size */
   double computation_amount;    /* Computation size */
   smx_action_t comm;            /* SIMIX modeling of communication */
   double message_size;          /* Data size */
   double computation_amount;    /* Computation size */

-  m_process_t sender;
-  m_process_t receiver;
+  msg_process_t sender;
+  msg_process_t receiver;

   m_host_t source;
   double priority;
   double rate;
   m_host_t source;
   double priority;
   double rate;


@@ -115,7 +115,7 @@ typedef struct MSG_Global {
   int PID;
   int session;
   unsigned long int sent_msg;   /* Total amount of messages sent during the simulation */
   int PID;
   int session;
   unsigned long int sent_msg;   /* Total amount of messages sent during the simulation */

-  void (*task_copy_callback) (m_task_t task, m_process_t src, m_process_t dst);
+  void (*task_copy_callback) (m_task_t task, msg_process_t src, msg_process_t dst);

   void_f_pvoid_t process_data_cleanup;
   xbt_swag_t vms;
 } s_MSG_Global_t, *MSG_Global_t;
   void_f_pvoid_t process_data_cleanup;
   xbt_swag_t vms;
 } s_MSG_Global_t, *MSG_Global_t;

diff --git a/src/msg/msg_process.c b/src/msg/msg_process.c
index 8da8fac..f279dab 100644 (file)
--- a/src/msg/msg_process.c
+++ b/src/msg/msg_process.c
@@ -18,7 +18,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_process, msg,
  *  the concept of <em>process</em> is at the heart of the
  *  simulator. A process may be defined as a <em>code</em>, with
  *  some <em>private data</em>, executing in a <em>location</em>.
  *  the concept of <em>process</em> is at the heart of the
  *  simulator. A process may be defined as a <em>code</em>, with
  *  some <em>private data</em>, executing in a <em>location</em>.

- *  \see m_process_t
+ *  \see msg_process_t

  */
 
 /******************************** Process ************************************/
  */
 
 /******************************** Process ************************************/


@@ -68,24 +68,24 @@ void MSG_process_create_from_SIMIX(smx_process_t* process, const char *name,
                                     xbt_dict_t properties, int auto_restart)
 {
   m_host_t host = MSG_get_host_by_name(hostname);
                                     xbt_dict_t properties, int auto_restart)
 {
   m_host_t host = MSG_get_host_by_name(hostname);

-  m_process_t p = MSG_process_create_with_environment(name, code, data,
+  msg_process_t p = MSG_process_create_with_environment(name, code, data,

                                                       host, argc, argv,
                                                       properties);
   if (p) {
     MSG_process_set_kill_time(p,kill_time);
     MSG_process_auto_restart_set(p,auto_restart);
   }
                                                       host, argc, argv,
                                                       properties);
   if (p) {
     MSG_process_set_kill_time(p,kill_time);
     MSG_process_auto_restart_set(p,auto_restart);
   }

-  *((m_process_t*) process) = p;
+  *((msg_process_t*) process) = p;

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

- * \brief Creates and runs a new #m_process_t.
+ * \brief Creates and runs a new #msg_process_t.

  *
  * Does exactly the same as #MSG_process_create_with_arguments but without
    providing standard arguments (\a argc, \a argv, \a start_time, \a kill_time).
  * \sa MSG_process_create_with_arguments
  */
  *
  * Does exactly the same as #MSG_process_create_with_arguments but without
    providing standard arguments (\a argc, \a argv, \a start_time, \a kill_time).
  * \sa MSG_process_create_with_arguments
  */

-m_process_t MSG_process_create(const char *name,
+msg_process_t MSG_process_create(const char *name,

                                xbt_main_func_t code, void *data,
                                m_host_t host)
 {
                                xbt_main_func_t code, void *data,
                                m_host_t host)
 {


@@ -94,16 +94,16 @@ m_process_t MSG_process_create(const char *name,
 }
 
 /** \ingroup m_process_management
 }
 
 /** \ingroup m_process_management

- * \brief Creates and runs a new #m_process_t.
+ * \brief Creates and runs a new #msg_process_t.

 
 

- * A constructor for #m_process_t taking four arguments and returning the
+ * A constructor for #msg_process_t taking four arguments and returning the

  * corresponding object. The structure (and the corresponding thread) is
  * created, and put in the list of ready process.
  * \param name a name for the object. It is for user-level information
    and can be NULL.
  * \param code is a function describing the behavior of the process. It
    should then only use functions described in \ref
  * corresponding object. The structure (and the corresponding thread) is
  * created, and put in the list of ready process.
  * \param name a name for the object. It is for user-level information
    and can be NULL.
  * \param code is a function describing the behavior of the process. It
    should then only use functions described in \ref

-   m_process_management (to create a new #m_process_t for example),
+   m_process_management (to create a new #msg_process_t for example),

    in \ref m_host_management (only the read-only functions i.e. whose
    name contains the word get), in \ref m_task_management (to create
    or destroy some #m_task_t for example) and in \ref
    in \ref m_host_management (only the read-only functions i.e. whose
    name contains the word get), in \ref m_task_management (to create
    or destroy some #m_task_t for example) and in \ref


@@ -114,11 +114,11 @@ m_process_t MSG_process_create(const char *name,
  * \param host the location where the new process is executed.
  * \param argc first argument passed to \a code
  * \param argv second argument passed to \a code
  * \param host the location where the new process is executed.
  * \param argc first argument passed to \a code
  * \param argv second argument passed to \a code

- * \see m_process_t
+ * \see msg_process_t

  * \return The new corresponding object.
  */
 
  * \return The new corresponding object.
  */
 

-m_process_t MSG_process_create_with_arguments(const char *name,
+msg_process_t MSG_process_create_with_arguments(const char *name,

                                               xbt_main_func_t code,
                                               void *data, m_host_t host,
                                               int argc, char **argv)
                                               xbt_main_func_t code,
                                               void *data, m_host_t host,
                                               int argc, char **argv)


@@ -128,16 +128,16 @@ m_process_t MSG_process_create_with_arguments(const char *name,
 }
 
 /** \ingroup m_process_management
 }
 
 /** \ingroup m_process_management

- * \brief Creates and runs a new #m_process_t.
+ * \brief Creates and runs a new #msg_process_t.

 
 

- * A constructor for #m_process_t taking four arguments and returning the
+ * A constructor for #msg_process_t taking four arguments and returning the

  * corresponding object. The structure (and the corresponding thread) is
  * created, and put in the list of ready process.
  * \param name a name for the object. It is for user-level information
    and can be NULL.
  * \param code is a function describing the behavior of the process. It
    should then only use functions described in \ref
  * corresponding object. The structure (and the corresponding thread) is
  * created, and put in the list of ready process.
  * \param name a name for the object. It is for user-level information
    and can be NULL.
  * \param code is a function describing the behavior of the process. It
    should then only use functions described in \ref

-   m_process_management (to create a new #m_process_t for example),
+   m_process_management (to create a new #msg_process_t for example),

    in \ref m_host_management (only the read-only functions i.e. whose
    name contains the word get), in \ref m_task_management (to create
    or destroy some #m_task_t for example) and in \ref
    in \ref m_host_management (only the read-only functions i.e. whose
    name contains the word get), in \ref m_task_management (to create
    or destroy some #m_task_t for example) and in \ref


@@ -149,10 +149,10 @@ m_process_t MSG_process_create_with_arguments(const char *name,
  * \param argc first argument passed to \a code
  * \param argv second argument passed to \a code
  * \param properties list a properties defined for this process
  * \param argc first argument passed to \a code
  * \param argv second argument passed to \a code
  * \param properties list a properties defined for this process

- * \see m_process_t
+ * \see msg_process_t

  * \return The new corresponding object.
  */
  * \return The new corresponding object.
  */

-m_process_t MSG_process_create_with_environment(const char *name,
+msg_process_t MSG_process_create_with_environment(const char *name,

                                                 xbt_main_func_t code,
                                                 void *data, m_host_t host,
                                                 int argc, char **argv,
                                                 xbt_main_func_t code,
                                                 void *data, m_host_t host,
                                                 int argc, char **argv,


@@ -160,7 +160,7 @@ m_process_t MSG_process_create_with_environment(const char *name,
 {
   xbt_assert(code != NULL && host != NULL, "Invalid parameters");
   simdata_process_t simdata = xbt_new0(s_simdata_process_t, 1);
 {
   xbt_assert(code != NULL && host != NULL, "Invalid parameters");
   simdata_process_t simdata = xbt_new0(s_simdata_process_t, 1);

-  m_process_t process;
+  msg_process_t process;

 
   /* Simulator data for MSG */
   simdata->PID = msg_global->PID++;
 
   /* Simulator data for MSG */
   simdata->PID = msg_global->PID++;


@@ -205,7 +205,7 @@ m_process_t MSG_process_create_with_environment(const char *name,
  *
  * This function simply kills a \a process... scary isn't it ? :)
  */
  *
  * This function simply kills a \a process... scary isn't it ? :)
  */

-void MSG_process_kill(m_process_t process)
+void MSG_process_kill(msg_process_t process)

 {
 //  /* FIXME: why do we only cancel communication actions? is this useful? */
 //  simdata_process_t p_simdata = simcall_process_get_data(process);
 {
 //  /* FIXME: why do we only cancel communication actions? is this useful? */
 //  simdata_process_t p_simdata = simcall_process_get_data(process);


@@ -224,7 +224,7 @@ void MSG_process_kill(m_process_t process)
  * This function checks whether \a process and \a host are valid pointers
    and change the value of the #m_host_t on which \a process is running.
  */
  * This function checks whether \a process and \a host are valid pointers
    and change the value of the #m_host_t on which \a process is running.
  */

-MSG_error_t MSG_process_migrate(m_process_t process, m_host_t host)
+MSG_error_t MSG_process_migrate(msg_process_t process, m_host_t host)

 {
   simdata_process_t simdata = simcall_process_get_data(process);
   simdata->m_host = host;
 {
   simdata_process_t simdata = simcall_process_get_data(process);
   simdata->m_host = host;


@@ -242,7 +242,7 @@ MSG_error_t MSG_process_migrate(m_process_t process, m_host_t host)
  * This function checks whether \a process is a valid pointer or not
    and returns the user data associated to this process.
  */
  * This function checks whether \a process is a valid pointer or not
    and returns the user data associated to this process.
  */

-void* MSG_process_get_data(m_process_t process)
+void* MSG_process_get_data(msg_process_t process)

 {
   xbt_assert(process != NULL, "Invalid parameter");
 
 {
   xbt_assert(process != NULL, "Invalid parameter");
 


@@ -257,7 +257,7 @@ void* MSG_process_get_data(m_process_t process)
  * This function checks whether \a process is a valid pointer or not
    and sets the user data associated to this process.
  */
  * This function checks whether \a process is a valid pointer or not
    and sets the user data associated to this process.
  */

-MSG_error_t MSG_process_set_data(m_process_t process, void *data)
+MSG_error_t MSG_process_set_data(msg_process_t process, void *data)

 {
   xbt_assert(process != NULL, "Invalid parameter");
 
 {
   xbt_assert(process != NULL, "Invalid parameter");
 


@@ -284,7 +284,7 @@ XBT_PUBLIC(void) MSG_process_set_data_cleanup(void_f_pvoid_t data_cleanup) {
  * \return the m_host_t corresponding to the location on which \a
  * process is running.
  */
  * \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(msg_process_t process)

 {
   simdata_process_t simdata;
   if (process == NULL) {
 {
   simdata_process_t simdata;
   if (process == NULL) {


@@ -298,13 +298,13 @@ m_host_t MSG_process_get_host(m_process_t process)
 
 /** \ingroup m_process_management
  *
 
 /** \ingroup m_process_management
  *

- * \brief Return a #m_process_t given its PID.
+ * \brief Return a #msg_process_t given its PID.

  *
  *

- * This function search in the list of all the created m_process_t for a m_process_t
+ * This function search in the list of all the created msg_process_t for a msg_process_t

    whose PID is equal to \a PID. If no host is found, \c NULL is returned.
    Note that the PID are uniq in the whole simulation, not only on a given host.
  */
    whose PID is equal to \a PID. If no host is found, \c NULL is returned.
    Note that the PID are uniq in the whole simulation, not only on a given host.
  */

-m_process_t MSG_process_from_PID(int PID)
+msg_process_t MSG_process_from_PID(int PID)

 {
   return SIMIX_process_from_PID(PID);
 }
 {
   return SIMIX_process_from_PID(PID);
 }


@@ -320,7 +320,7 @@ xbt_dynar_t MSG_processes_as_dynar(void) {
  * \param process a process
  * \param kill_time the time when the process is killed.
  */
  * \param process a process
  * \param kill_time the time when the process is killed.
  */

-MSG_error_t MSG_process_set_kill_time(m_process_t process, double kill_time)
+MSG_error_t MSG_process_set_kill_time(msg_process_t process, double kill_time)

 {
   simcall_process_set_kill_time(process,kill_time);
   return MSG_OK;
 {
   simcall_process_set_kill_time(process,kill_time);
   return MSG_OK;


@@ -332,7 +332,7 @@ MSG_error_t MSG_process_set_kill_time(m_process_t process, double kill_time)
  * This function checks whether \a process is a valid pointer or not
    and return its PID (or 0 in case of problem).
  */
  * This function checks whether \a process is a valid pointer or not
    and return its PID (or 0 in case of problem).
  */

-int MSG_process_get_PID(m_process_t process)
+int MSG_process_get_PID(msg_process_t process)

 {
   /* Do not raise an exception here: this function is called by the logs
    * and the exceptions, so it would be called back again and again */
 {
   /* Do not raise an exception here: this function is called by the logs
    * and the exceptions, so it would be called back again and again */


@@ -352,7 +352,7 @@ int MSG_process_get_PID(m_process_t process)
    and return its PID. Returns -1 if the process has not been created by
    any other process.
  */
    and return its PID. Returns -1 if the process has not been created by
    any other process.
  */

-int MSG_process_get_PPID(m_process_t process)
+int MSG_process_get_PPID(msg_process_t process)

 {
   xbt_assert(process != NULL, "Invalid parameter");
 
 {
   xbt_assert(process != NULL, "Invalid parameter");
 


@@ -367,7 +367,7 @@ int MSG_process_get_PPID(m_process_t process)
  * This function checks whether \a process is a valid pointer or not
    and return its name.
  */
  * This function checks whether \a process is a valid pointer or not
    and return its name.
  */

-const char *MSG_process_get_name(m_process_t process)
+const char *MSG_process_get_name(msg_process_t process)

 {
   xbt_assert(process, "Invalid parameter");
 
 {
   xbt_assert(process, "Invalid parameter");
 


@@ -381,7 +381,7 @@ const char *MSG_process_get_name(m_process_t process)
  * \param name a property name
  * \return value of a property (or NULL if the property is not set)
  */
  * \param name a property name
  * \return value of a property (or NULL if the property is not set)
  */

-const char *MSG_process_get_property_value(m_process_t process,
+const char *MSG_process_get_property_value(msg_process_t process,

                                            const char *name)
 {
   return xbt_dict_get_or_null(MSG_process_get_properties(process), name);
                                            const char *name)
 {
   return xbt_dict_get_or_null(MSG_process_get_properties(process), name);


@@ -392,7 +392,7 @@ const char *MSG_process_get_property_value(m_process_t process,
  *
  * This function returns all the parameters associated with a process
  */
  *
  * This function returns all the parameters associated with a process
  */

-xbt_dict_t MSG_process_get_properties(m_process_t process)
+xbt_dict_t MSG_process_get_properties(msg_process_t process)

 {
   xbt_assert(process != NULL, "Invalid parameter");
 
 {
   xbt_assert(process != NULL, "Invalid parameter");
 


@@ -403,7 +403,7 @@ xbt_dict_t MSG_process_get_properties(m_process_t process)
 /** \ingroup m_process_management
  * \brief Return the PID of the current process.
  *
 /** \ingroup m_process_management
  * \brief Return the PID of the current process.
  *

- * This function returns the PID of the currently running #m_process_t.
+ * This function returns the PID of the currently running #msg_process_t.

  */
 int MSG_process_self_PID(void)
 {
  */
 int MSG_process_self_PID(void)
 {


@@ -414,7 +414,7 @@ int MSG_process_self_PID(void)
  * \brief Return the PPID of the current process.
  *
  * This function returns the PID of the parent of the currently
  * \brief Return the PPID of the current process.
  *
  * This function returns the PID of the parent of the currently

- * running #m_process_t.
+ * running #msg_process_t.

  */
 int MSG_process_self_PPID(void)
 {
  */
 int MSG_process_self_PPID(void)
 {


@@ -424,9 +424,9 @@ int MSG_process_self_PPID(void)
 /** \ingroup m_process_management
  * \brief Return the current process.
  *
 /** \ingroup m_process_management
  * \brief Return the current process.
  *

- * This function returns the currently running #m_process_t.
+ * This function returns the currently running #msg_process_t.

  */
  */

-m_process_t MSG_process_self(void)
+msg_process_t MSG_process_self(void)

 {
   return SIMIX_process_self();
 }
 {
   return SIMIX_process_self();
 }


@@ -437,7 +437,7 @@ m_process_t MSG_process_self(void)
  * This function suspends the process by suspending the task on which
  * it was waiting for the completion.
  */
  * This function suspends the process by suspending the task on which
  * it was waiting for the completion.
  */

-MSG_error_t MSG_process_suspend(m_process_t process)
+MSG_error_t MSG_process_suspend(msg_process_t process)

 {
   xbt_assert(process != NULL, "Invalid parameter");
 
 {
   xbt_assert(process != NULL, "Invalid parameter");
 


@@ -455,7 +455,7 @@ MSG_error_t MSG_process_suspend(m_process_t process)
  * This function resumes a suspended process by resuming the task on
  * which it was waiting for the completion.
  */
  * This function resumes a suspended process by resuming the task on
  * which it was waiting for the completion.
  */

-MSG_error_t MSG_process_resume(m_process_t process)
+MSG_error_t MSG_process_resume(msg_process_t process)

 {
   xbt_assert(process != NULL, "Invalid parameter");
 
 {
   xbt_assert(process != NULL, "Invalid parameter");
 


@@ -473,13 +473,13 @@ MSG_error_t MSG_process_resume(m_process_t process)
  * This checks whether a process is suspended or not by inspecting the
  * task on which it was waiting for the completion.
  */
  * This checks whether a process is suspended or not by inspecting the
  * task on which it was waiting for the completion.
  */

-int MSG_process_is_suspended(m_process_t process)
+int MSG_process_is_suspended(msg_process_t process)

 {
   xbt_assert(process != NULL, "Invalid parameter");
   return simcall_process_is_suspended(process);
 }
 
 {
   xbt_assert(process != NULL, "Invalid parameter");
   return simcall_process_is_suspended(process);
 }
 

-smx_context_t MSG_process_get_smx_ctx(m_process_t process) {
+smx_context_t MSG_process_get_smx_ctx(msg_process_t process) {

   return SIMIX_process_get_context(process);
 }
 /**
   return SIMIX_process_get_context(process);
 }
 /**


@@ -497,6 +497,6 @@ void MSG_process_on_exit(int_f_pvoid_t fun, void *data) {
  * If the flag is set to 1, the process will be automatically restarted when
  * its host comes back up.
  */
  * If the flag is set to 1, the process will be automatically restarted when
  * its host comes back up.
  */

-XBT_PUBLIC(void) MSG_process_auto_restart_set(m_process_t process, int auto_restart) {
+XBT_PUBLIC(void) MSG_process_auto_restart_set(msg_process_t process, int auto_restart) {

   simcall_process_auto_restart_set(process,auto_restart);
 }
   simcall_process_auto_restart_set(process,auto_restart);
 }

diff --git a/src/msg/msg_task.c b/src/msg/msg_task.c
index 57f4602..1462a82 100644 (file)
--- a/src/msg/msg_task.c
+++ b/src/msg/msg_task.c
@@ -193,7 +193,7 @@ void MSG_task_set_data(m_task_t task, void *data)
  * \param callback a callback function
  */
 void MSG_task_set_copy_callback(void (*callback)
  * \param callback a callback function
  */
 void MSG_task_set_copy_callback(void (*callback)

-    (m_task_t task, m_process_t sender, m_process_t receiver)) {
+    (m_task_t task, msg_process_t sender, msg_process_t receiver)) {

 
   msg_global->task_copy_callback = callback;
 
 
   msg_global->task_copy_callback = callback;
 


@@ -208,9 +208,9 @@ void MSG_task_set_copy_callback(void (*callback)
 /** \ingroup m_task_management
  * \brief Return the sender of a #m_task_t.
  *
 /** \ingroup m_task_management
  * \brief Return the sender of a #m_task_t.
  *

- * This functions returns the #m_process_t which sent this task
+ * This functions returns the #msg_process_t which sent this task

  */
  */

-m_process_t MSG_task_get_sender(m_task_t task)
+msg_process_t MSG_task_get_sender(m_task_t task)

 {
   xbt_assert(task, "Invalid parameters");
   return ((simdata_task_t) task->simdata)->sender;
 {
   xbt_assert(task, "Invalid parameters");
   return ((simdata_task_t) task->simdata)->sender;

diff --git a/src/msg/msg_vm.c b/src/msg/msg_vm.c
index f337ec0..79c8c32 100644 (file)
--- a/src/msg/msg_vm.c
+++ b/src/msg/msg_vm.c
@@ -24,7 +24,7 @@ msg_vm_t MSG_vm_start(m_host_t location, int coreAmount) {
   res->state = msg_vm_state_running;
   res->location = location;
   res->coreAmount = coreAmount;
   res->state = msg_vm_state_running;
   res->location = location;
   res->coreAmount = coreAmount;

-  res->processes = xbt_dynar_new(sizeof(m_process_t),NULL);
+  res->processes = xbt_dynar_new(sizeof(msg_process_t),NULL);

 
   xbt_swag_insert(res,msg_global->vms);
   xbt_swag_insert(res,location->vms);
 
   xbt_swag_insert(res,msg_global->vms);
   xbt_swag_insert(res,location->vms);


@@ -63,7 +63,7 @@ int MSG_vm_is_running(msg_vm_t vm) {
  * Afterward, when the VM is migrated or suspended or whatever, the process will have the corresponding handling, too.
  *
  */
  * Afterward, when the VM is migrated or suspended or whatever, the process will have the corresponding handling, too.
  *
  */

-void MSG_vm_bind(msg_vm_t vm, m_process_t process) {
+void MSG_vm_bind(msg_vm_t vm, msg_process_t process) {

   /* check if the process is already in a VM */
   simdata_process_t simdata = simcall_process_get_data(process);
   if (simdata->vm) {
   /* check if the process is already in a VM */
   simdata_process_t simdata = simcall_process_get_data(process);
   if (simdata->vm) {


@@ -79,14 +79,14 @@ void MSG_vm_bind(msg_vm_t vm, m_process_t process) {
 
   XBT_DEBUG("binding Process %s to %p",MSG_process_get_name(process),vm);
 
 
   XBT_DEBUG("binding Process %s to %p",MSG_process_get_name(process),vm);
 

-  xbt_dynar_push_as(vm->processes,m_process_t,process);
+  xbt_dynar_push_as(vm->processes,msg_process_t,process);

 }
 /** @brief Removes the given process from the given VM, and kill it
  *  @ingroup msg_VMs
  *
  *  Will raise a not_found exception if the process were not binded to that VM
  */
 }
 /** @brief Removes the given process from the given VM, and kill it
  *  @ingroup msg_VMs
  *
  *  Will raise a not_found exception if the process were not binded to that VM
  */

-void MSG_vm_unbind(msg_vm_t vm, m_process_t process) {
+void MSG_vm_unbind(msg_vm_t vm, msg_process_t process) {

   int pos = xbt_dynar_search(vm->processes,process);
   xbt_dynar_remove_at(vm->processes,pos, NULL);
   MSG_process_kill(process);
   int pos = xbt_dynar_search(vm->processes,process);
   xbt_dynar_remove_at(vm->processes,pos, NULL);
   MSG_process_kill(process);


@@ -101,7 +101,7 @@ void MSG_vm_unbind(msg_vm_t vm, m_process_t process) {
  */
 void MSG_vm_migrate(msg_vm_t vm, m_host_t destination) {
   unsigned int cpt;
  */
 void MSG_vm_migrate(msg_vm_t vm, m_host_t destination) {
   unsigned int cpt;

-  m_process_t process;
+  msg_process_t process;

   xbt_dynar_foreach(vm->processes,cpt,process) {
     MSG_process_migrate(process,destination);
   }
   xbt_dynar_foreach(vm->processes,cpt,process) {
     MSG_process_migrate(process,destination);
   }


@@ -119,7 +119,7 @@ void MSG_vm_migrate(msg_vm_t vm, m_host_t destination) {
  */
 void MSG_vm_suspend(msg_vm_t vm) {
   unsigned int cpt;
  */
 void MSG_vm_suspend(msg_vm_t vm) {
   unsigned int cpt;

-  m_process_t process;
+  msg_process_t process;

   xbt_dynar_foreach(vm->processes,cpt,process) {
     XBT_DEBUG("suspend process %s of host %s",MSG_process_get_name(process),MSG_host_get_name(MSG_process_get_host(process)));
     MSG_process_suspend(process);
   xbt_dynar_foreach(vm->processes,cpt,process) {
     XBT_DEBUG("suspend process %s of host %s",MSG_process_get_name(process),MSG_host_get_name(MSG_process_get_host(process)));
     MSG_process_suspend(process);


@@ -135,7 +135,7 @@ void MSG_vm_suspend(msg_vm_t vm) {
  */
 void MSG_vm_resume(msg_vm_t vm) {
   unsigned int cpt;
  */
 void MSG_vm_resume(msg_vm_t vm) {
   unsigned int cpt;

-  m_process_t process;
+  msg_process_t process;

   xbt_dynar_foreach(vm->processes,cpt,process) {
     XBT_DEBUG("resume process %s of host %s",MSG_process_get_name(process),MSG_host_get_name(MSG_process_get_host(process)));
     MSG_process_resume(process);
   xbt_dynar_foreach(vm->processes,cpt,process) {
     XBT_DEBUG("resume process %s of host %s",MSG_process_get_name(process),MSG_host_get_name(MSG_process_get_host(process)));
     MSG_process_resume(process);


@@ -150,10 +150,10 @@ void MSG_vm_resume(msg_vm_t vm) {
  */
 void MSG_vm_shutdown(msg_vm_t vm)
 {
  */
 void MSG_vm_shutdown(msg_vm_t vm)
 {

-  m_process_t process;
+  msg_process_t process;

   XBT_DEBUG("%lu processes in the VM", xbt_dynar_length(vm->processes));
   while (xbt_dynar_length(vm->processes) > 0) {
   XBT_DEBUG("%lu processes in the VM", xbt_dynar_length(vm->processes));
   while (xbt_dynar_length(vm->processes) > 0) {

-    process = xbt_dynar_get_as(vm->processes,0,m_process_t);
+    process = xbt_dynar_get_as(vm->processes,0,msg_process_t);

     MSG_process_kill(process);
   }
 }
     MSG_process_kill(process);
   }
 }


@@ -163,7 +163,7 @@ void MSG_vm_shutdown(msg_vm_t vm)
  */
 void MSG_vm_destroy(msg_vm_t vm) {
   unsigned int cpt;
  */
 void MSG_vm_destroy(msg_vm_t vm) {
   unsigned int cpt;

-  m_process_t process;
+  msg_process_t process;

   xbt_dynar_foreach(vm->processes,cpt,process) {
     //FIXME: Slow ?
     simdata_process_t simdata = simcall_process_get_data(process);
   xbt_dynar_foreach(vm->processes,cpt,process) {
     //FIXME: Slow ?
     simdata_process_t simdata = simcall_process_get_data(process);