Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
try to simplify the way simcalls are generated
[simgrid.git] / src / simix / simcalls_generated_body.c
index d1e2a6d..8ab78ed 100644 (file)
@@ -1,11 +1,13 @@
-/*********************************************
- * File Generated by src/simix/simcalls.py   *
- *                from src/simix/simcalls.in *
- * Do not modify this file, add new simcalls *
- * in src/simix/simcalls.in                  *
- *********************************************/
+/**********************************************************************/
+/* File Generated by src/simix/simcalls.py from src/simix/simcalls.in */
+/*                                                                    */
+/*                    DO NOT EVER CHANGE THIS FILE                    */
+/*                                                                    */
+/* change simcalls specification in src/simix/simcalls.in             */
+/**********************************************************************/
 
-  inline static smx_host_t simcall_BODY_host_get_by_name(const char* name) {
+  
+inline static smx_host_t simcall_BODY_host_get_by_name(const char* name) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
@@ -25,7 +27,8 @@
     }    
     return self->simcall.result.dp;
   }
-  inline static const char* simcall_BODY_host_get_name(smx_host_t host) {
+  
+inline static const char* simcall_BODY_host_get_name(smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
@@ -45,7 +48,8 @@
     }    
     return self->simcall.result.cc;
   }
-  inline static void simcall_BODY_host_on(smx_host_t host) {
+  
+inline static void simcall_BODY_host_on(smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
@@ -65,7 +69,8 @@
     }    
     
   }
-  inline static void simcall_BODY_host_off(smx_host_t host) {
+  
+inline static void simcall_BODY_host_off(smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
@@ -85,7 +90,8 @@
     }    
     
   }
-  inline static xbt_dict_t simcall_BODY_host_get_properties(smx_host_t host) {
+  
+inline static xbt_dict_t simcall_BODY_host_get_properties(smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static int simcall_BODY_host_get_core(smx_host_t host) {
+  
+inline static int simcall_BODY_host_get_core(smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static xbt_swag_t simcall_BODY_host_get_process_list(smx_host_t host) {
+  
+inline static xbt_swag_t simcall_BODY_host_get_process_list(smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static double simcall_BODY_host_get_speed(smx_host_t host) {
+  
+inline static double simcall_BODY_host_get_speed(smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.d;
   }
-  inline static double simcall_BODY_host_get_available_speed(smx_host_t host) {
+  
+inline static double simcall_BODY_host_get_available_speed(smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.d;
   }
-  inline static int simcall_BODY_host_get_state(smx_host_t host) {
+  
+inline static int simcall_BODY_host_get_state(smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static double simcall_BODY_host_get_current_power_peak(smx_host_t host) {
+  
+inline static double simcall_BODY_host_get_current_power_peak(smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.d;
   }
-  inline static double simcall_BODY_host_get_power_peak_at(smx_host_t host, int pstate_index) {
+  
+inline static double simcall_BODY_host_get_power_peak_at(smx_host_t host, int pstate_index) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.d;
   }
-  inline static int simcall_BODY_host_get_nb_pstates(smx_host_t host) {
+  
+inline static int simcall_BODY_host_get_nb_pstates(smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static void simcall_BODY_host_set_power_peak_at(smx_host_t host, int pstate_index) {
+  
+inline static void simcall_BODY_host_set_power_peak_at(smx_host_t host, int pstate_index) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static double simcall_BODY_host_get_consumed_energy(smx_host_t host) {
+  
+inline static double simcall_BODY_host_get_consumed_energy(smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.d;
   }
-  inline static smx_action_t simcall_BODY_host_execute(const char* name, smx_host_t host, double computation_amount, double priority, double bound, unsigned long affinity_mask) {
+  
+inline static smx_action_t simcall_BODY_host_execute(const char* name, smx_host_t host, double computation_amount, double priority, double bound, unsigned long affinity_mask) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static smx_action_t simcall_BODY_host_parallel_execute(const char* name, int host_nb, smx_host_t* host_list, double* computation_amount, double* communication_amount, double amount, double rate) {
+  
+inline static smx_action_t simcall_BODY_host_parallel_execute(const char* name, int host_nb, smx_host_t* host_list, double* computation_amount, double* communication_amount, double amount, double rate) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static void simcall_BODY_host_execution_destroy(smx_action_t execution) {
+  
+inline static void simcall_BODY_host_execution_destroy(smx_action_t execution) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_host_execution_cancel(smx_action_t execution) {
+  
+inline static void simcall_BODY_host_execution_cancel(smx_action_t execution) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static double simcall_BODY_host_execution_get_remains(smx_action_t execution) {
+  
+inline static double simcall_BODY_host_execution_get_remains(smx_action_t execution) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.d;
   }
-  inline static int simcall_BODY_host_execution_get_state(smx_action_t execution) {
+  
+inline static int simcall_BODY_host_execution_get_state(smx_action_t execution) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static void simcall_BODY_host_execution_set_priority(smx_action_t execution, double priority) {
+  
+inline static void simcall_BODY_host_execution_set_priority(smx_action_t execution, double priority) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_host_execution_set_bound(smx_action_t execution, double bound) {
+  
+inline static void simcall_BODY_host_execution_set_bound(smx_action_t execution, double bound) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_host_execution_set_affinity(smx_action_t execution, smx_host_t ws, unsigned long mask) {
+  
+inline static void simcall_BODY_host_execution_set_affinity(smx_action_t execution, smx_host_t ws, unsigned long mask) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static int simcall_BODY_host_execution_wait(smx_action_t execution) {
+  
+inline static int simcall_BODY_host_execution_wait(smx_action_t execution) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static xbt_dict_t simcall_BODY_host_get_mounted_storage_list(smx_host_t host) {
+  
+inline static xbt_dict_t simcall_BODY_host_get_mounted_storage_list(smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static xbt_dynar_t simcall_BODY_host_get_attached_storage_list(smx_host_t host) {
+  
+inline static xbt_dynar_t simcall_BODY_host_get_attached_storage_list(smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static void simcall_BODY_host_get_params(smx_host_t ind_vm, ws_params_t params) {
+  
+inline static void simcall_BODY_host_get_params(smx_host_t ind_vm, ws_params_t params) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_host_set_params(smx_host_t ind_vm, ws_params_t params) {
+  
+inline static void simcall_BODY_host_set_params(smx_host_t ind_vm, ws_params_t params) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void* simcall_BODY_vm_create(const char* name, smx_host_t ind_pm) {
+  
+inline static void* simcall_BODY_vm_create(const char* name, smx_host_t ind_pm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static void simcall_BODY_vm_start(smx_host_t ind_vm) {
+  
+inline static void simcall_BODY_vm_start(smx_host_t ind_vm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static int simcall_BODY_vm_get_state(smx_host_t ind_vm) {
+  
+inline static int simcall_BODY_vm_get_state(smx_host_t ind_vm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static void simcall_BODY_vm_migrate(smx_host_t ind_vm, smx_host_t ind_dst_pm) {
+  
+inline static void simcall_BODY_vm_migrate(smx_host_t ind_vm, smx_host_t ind_dst_pm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void* simcall_BODY_vm_get_pm(smx_host_t ind_vm) {
+  
+inline static void* simcall_BODY_vm_get_pm(smx_host_t ind_vm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static void simcall_BODY_vm_set_bound(smx_host_t ind_vm, double bound) {
+  
+inline static void simcall_BODY_vm_set_bound(smx_host_t ind_vm, double bound) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_vm_set_affinity(smx_host_t ind_vm, smx_host_t ind_pm, unsigned long mask) {
+  
+inline static void simcall_BODY_vm_set_affinity(smx_host_t ind_vm, smx_host_t ind_pm, unsigned long mask) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_vm_destroy(smx_host_t ind_vm) {
+  
+inline static void simcall_BODY_vm_destroy(smx_host_t ind_vm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_vm_suspend(smx_host_t ind_vm) {
+  
+inline static void simcall_BODY_vm_suspend(smx_host_t ind_vm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_vm_resume(smx_host_t ind_vm) {
+  
+inline static void simcall_BODY_vm_resume(smx_host_t ind_vm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_vm_shutdown(smx_host_t ind_vm) {
+  
+inline static void simcall_BODY_vm_shutdown(smx_host_t ind_vm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_vm_save(smx_host_t ind_vm) {
+  
+inline static void simcall_BODY_vm_save(smx_host_t ind_vm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_vm_restore(smx_host_t ind_vm) {
+  
+inline static void simcall_BODY_vm_restore(smx_host_t ind_vm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_process_create(smx_process_t* process, const char* name, xbt_main_func_t code, void* data, const char* hostname, double kill_time, int argc, char** argv, xbt_dict_t properties, int auto_restart) {
+  
+inline static void simcall_BODY_process_create(smx_process_t* process, const char* name, xbt_main_func_t code, void* data, const char* hostname, double kill_time, int argc, char** argv, xbt_dict_t properties, int auto_restart) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_process_kill(smx_process_t process) {
+  
+inline static void simcall_BODY_process_kill(smx_process_t process) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_process_killall(int reset_pid) {
+  
+inline static void simcall_BODY_process_killall(int reset_pid) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_process_cleanup(smx_process_t process) {
+  
+inline static void simcall_BODY_process_cleanup(smx_process_t process) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_process_change_host(smx_process_t process, smx_host_t dest) {
+  
+inline static void simcall_BODY_process_change_host(smx_process_t process, smx_host_t dest) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_process_suspend(smx_process_t process) {
+  
+inline static void simcall_BODY_process_suspend(smx_process_t process) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_process_resume(smx_process_t process) {
+  
+inline static void simcall_BODY_process_resume(smx_process_t process) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static int simcall_BODY_process_count() {
+  
+inline static int simcall_BODY_process_count() {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static int simcall_BODY_process_get_PID(smx_process_t process) {
+  
+inline static int simcall_BODY_process_get_PID(smx_process_t process) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static int simcall_BODY_process_get_PPID(smx_process_t process) {
+  
+inline static int simcall_BODY_process_get_PPID(smx_process_t process) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static void* simcall_BODY_process_get_data(smx_process_t process) {
+  
+inline static void* simcall_BODY_process_get_data(smx_process_t process) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static void simcall_BODY_process_set_data(smx_process_t process, void* data) {
+  
+inline static void simcall_BODY_process_set_data(smx_process_t process, void* data) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static smx_host_t simcall_BODY_process_get_host(smx_process_t process) {
+  
+inline static smx_host_t simcall_BODY_process_get_host(smx_process_t process) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static const char* simcall_BODY_process_get_name(smx_process_t process) {
+  
+inline static const char* simcall_BODY_process_get_name(smx_process_t process) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.cc;
   }
-  inline static int simcall_BODY_process_is_suspended(smx_process_t process) {
+  
+inline static int simcall_BODY_process_is_suspended(smx_process_t process) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static xbt_dict_t simcall_BODY_process_get_properties(smx_process_t process) {
+  
+inline static xbt_dict_t simcall_BODY_process_get_properties(smx_process_t process) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static int simcall_BODY_process_join(smx_process_t process, double timeout) {
+  
+inline static int simcall_BODY_process_join(smx_process_t process, double timeout) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static int simcall_BODY_process_sleep(double duration) {
+  
+inline static int simcall_BODY_process_sleep(double duration) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static void simcall_BODY_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void* data) {
+  
+inline static void simcall_BODY_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void* data) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_process_auto_restart_set(smx_process_t process, int auto_restart) {
+  
+inline static void simcall_BODY_process_auto_restart_set(smx_process_t process, int auto_restart) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static smx_process_t simcall_BODY_process_restart(smx_process_t process) {
+  
+inline static smx_process_t simcall_BODY_process_restart(smx_process_t process) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static smx_rdv_t simcall_BODY_rdv_create(const char* name) {
+  
+inline static smx_rdv_t simcall_BODY_rdv_create(const char* name) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static void simcall_BODY_rdv_destroy(smx_rdv_t rdv) {
+  
+inline static void simcall_BODY_rdv_destroy(smx_rdv_t rdv) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static unsigned int simcall_BODY_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host) {
+  
+inline static unsigned int simcall_BODY_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.ui;
   }
-  inline static smx_action_t simcall_BODY_rdv_get_head(smx_rdv_t rdv) {
+  
+inline static smx_action_t simcall_BODY_rdv_get_head(smx_rdv_t rdv) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static void simcall_BODY_rdv_set_receiver(smx_rdv_t rdv, smx_process_t receiver) {
+  
+inline static void simcall_BODY_rdv_set_receiver(smx_rdv_t rdv, smx_process_t receiver) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static smx_process_t simcall_BODY_rdv_get_receiver(smx_rdv_t rdv) {
+  
+inline static smx_process_t simcall_BODY_rdv_get_receiver(smx_rdv_t rdv) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static smx_action_t simcall_BODY_comm_iprobe(smx_rdv_t rdv, int type, int src, int tag, simix_match_func_t match_fun, void* data) {
+  
+inline static smx_action_t simcall_BODY_comm_iprobe(smx_rdv_t rdv, int type, int src, int tag, simix_match_func_t match_fun, void* data) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static void simcall_BODY_comm_send(smx_process_t src, smx_rdv_t rdv, double task_size, double rate, void* src_buff, size_t src_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double timeout) {
+  
+inline static void simcall_BODY_comm_send(smx_process_t src, smx_rdv_t rdv, double task_size, double rate, void* src_buff, size_t src_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double timeout) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static smx_action_t simcall_BODY_comm_isend(smx_process_t src, smx_rdv_t rdv, double task_size, double rate, void* src_buff, size_t src_buff_size, simix_match_func_t match_fun, simix_clean_func_t clean_fun, simix_copy_data_func_t copy_data_fun, void* data, int detached) {
+  
+inline static smx_action_t simcall_BODY_comm_isend(smx_process_t src, smx_rdv_t rdv, double task_size, double rate, void* src_buff, size_t src_buff_size, simix_match_func_t match_fun, simix_clean_func_t clean_fun, simix_copy_data_func_t copy_data_fun, void* data, int detached) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static void simcall_BODY_comm_recv(smx_rdv_t rdv, void* dst_buff, size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double timeout, double rate) {
+  
+inline static void simcall_BODY_comm_recv(smx_rdv_t rdv, void* dst_buff, size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double timeout, double rate) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static smx_action_t simcall_BODY_comm_irecv(smx_rdv_t rdv, void* dst_buff, size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double rate) {
+  
+inline static smx_action_t simcall_BODY_comm_irecv(smx_rdv_t rdv, void* dst_buff, size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double rate) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static void simcall_BODY_comm_cancel(smx_action_t comm) {
+  
+inline static void simcall_BODY_comm_cancel(smx_action_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static int simcall_BODY_comm_waitany(xbt_dynar_t comms) {
+  
+inline static int simcall_BODY_comm_waitany(xbt_dynar_t comms) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static void simcall_BODY_comm_wait(smx_action_t comm, double timeout) {
+  
+inline static void simcall_BODY_comm_wait(smx_action_t comm, double timeout) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static int simcall_BODY_comm_test(smx_action_t comm) {
+  
+inline static int simcall_BODY_comm_test(smx_action_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static int simcall_BODY_comm_testany(xbt_dynar_t comms) {
+  
+inline static int simcall_BODY_comm_testany(xbt_dynar_t comms) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static double simcall_BODY_comm_get_remains(smx_action_t comm) {
+  
+inline static double simcall_BODY_comm_get_remains(smx_action_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.d;
   }
-  inline static int simcall_BODY_comm_get_state(smx_action_t comm) {
+  
+inline static int simcall_BODY_comm_get_state(smx_action_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static void* simcall_BODY_comm_get_src_data(smx_action_t comm) {
+  
+inline static void* simcall_BODY_comm_get_src_data(smx_action_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static void* simcall_BODY_comm_get_dst_data(smx_action_t comm) {
+  
+inline static void* simcall_BODY_comm_get_dst_data(smx_action_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static smx_process_t simcall_BODY_comm_get_src_proc(smx_action_t comm) {
+  
+inline static smx_process_t simcall_BODY_comm_get_src_proc(smx_action_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static smx_process_t simcall_BODY_comm_get_dst_proc(smx_action_t comm) {
+  
+inline static smx_process_t simcall_BODY_comm_get_dst_proc(smx_action_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static smx_mutex_t simcall_BODY_mutex_init() {
+  
+inline static smx_mutex_t simcall_BODY_mutex_init() {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static void simcall_BODY_mutex_destroy(smx_mutex_t mutex) {
+  
+inline static void simcall_BODY_mutex_destroy(smx_mutex_t mutex) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_mutex_lock(smx_mutex_t mutex) {
+  
+inline static void simcall_BODY_mutex_lock(smx_mutex_t mutex) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static int simcall_BODY_mutex_trylock(smx_mutex_t mutex) {
+  
+inline static int simcall_BODY_mutex_trylock(smx_mutex_t mutex) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static void simcall_BODY_mutex_unlock(smx_mutex_t mutex) {
+  
+inline static void simcall_BODY_mutex_unlock(smx_mutex_t mutex) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static smx_cond_t simcall_BODY_cond_init() {
+  
+inline static smx_cond_t simcall_BODY_cond_init() {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static void simcall_BODY_cond_destroy(smx_cond_t cond) {
+  
+inline static void simcall_BODY_cond_destroy(smx_cond_t cond) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_cond_signal(smx_cond_t cond) {
+  
+inline static void simcall_BODY_cond_signal(smx_cond_t cond) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_cond_wait(smx_cond_t cond, smx_mutex_t mutex) {
+  
+inline static void simcall_BODY_cond_wait(smx_cond_t cond, smx_mutex_t mutex) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) {
+  
+inline static void simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_cond_broadcast(smx_cond_t cond) {
+  
+inline static void simcall_BODY_cond_broadcast(smx_cond_t cond) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static smx_sem_t simcall_BODY_sem_init(int capacity) {
+  
+inline static smx_sem_t simcall_BODY_sem_init(int capacity) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static void simcall_BODY_sem_destroy(smx_sem_t sem) {
+  
+inline static void simcall_BODY_sem_destroy(smx_sem_t sem) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_sem_release(smx_sem_t sem) {
+  
+inline static void simcall_BODY_sem_release(smx_sem_t sem) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static int simcall_BODY_sem_would_block(smx_sem_t sem) {
+  
+inline static int simcall_BODY_sem_would_block(smx_sem_t sem) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static void simcall_BODY_sem_acquire(smx_sem_t sem) {
+  
+inline static void simcall_BODY_sem_acquire(smx_sem_t sem) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static void simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout) {
+  
+inline static void simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     
   }
-  inline static int simcall_BODY_sem_get_capacity(smx_sem_t sem) {
+  
+inline static int simcall_BODY_sem_get_capacity(smx_sem_t sem) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static sg_size_t simcall_BODY_file_read(smx_file_t fd, sg_size_t size, smx_host_t host) {
+  
+inline static sg_size_t simcall_BODY_file_read(smx_file_t fd, sg_size_t size, smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.sgsz;
   }
-  inline static sg_size_t simcall_BODY_file_write(smx_file_t fd, sg_size_t size, smx_host_t host) {
+  
+inline static sg_size_t simcall_BODY_file_write(smx_file_t fd, sg_size_t size, smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.sgsz;
   }
-  inline static smx_file_t simcall_BODY_file_open(const char* fullpath, smx_host_t host) {
+  
+inline static smx_file_t simcall_BODY_file_open(const char* fullpath, smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static int simcall_BODY_file_close(smx_file_t fd, smx_host_t host) {
+  
+inline static int simcall_BODY_file_close(smx_file_t fd, smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static int simcall_BODY_file_unlink(smx_file_t fd, smx_host_t host) {
+  
+inline static int simcall_BODY_file_unlink(smx_file_t fd, smx_host_t host) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static sg_size_t simcall_BODY_file_get_size(smx_file_t fd) {
+  
+inline static sg_size_t simcall_BODY_file_get_size(smx_file_t fd) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.sgsz;
   }
-  inline static sg_size_t simcall_BODY_file_tell(smx_file_t fd) {
+  
+inline static sg_size_t simcall_BODY_file_tell(smx_file_t fd) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.sgsz;
   }
-  inline static int simcall_BODY_file_seek(smx_file_t fd, sg_offset_t offset, int origin) {
+  
+inline static int simcall_BODY_file_seek(smx_file_t fd, sg_offset_t offset, int origin) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static xbt_dynar_t simcall_BODY_file_get_info(smx_file_t fd) {
+  
+inline static xbt_dynar_t simcall_BODY_file_get_info(smx_file_t fd) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static int simcall_BODY_file_move(smx_file_t fd, const char* fullpath) {
+  
+inline static int simcall_BODY_file_move(smx_file_t fd, const char* fullpath) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static sg_size_t simcall_BODY_storage_get_free_size(smx_storage_t storage) {
+  
+inline static sg_size_t simcall_BODY_storage_get_free_size(smx_storage_t storage) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.sgsz;
   }
-  inline static sg_size_t simcall_BODY_storage_get_used_size(smx_storage_t name) {
+  
+inline static sg_size_t simcall_BODY_storage_get_used_size(smx_storage_t name) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.sgsz;
   }
-  inline static xbt_dict_t simcall_BODY_storage_get_properties(smx_storage_t storage) {
+  
+inline static xbt_dict_t simcall_BODY_storage_get_properties(smx_storage_t storage) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static xbt_dict_t simcall_BODY_storage_get_content(smx_storage_t storage) {
+  
+inline static xbt_dict_t simcall_BODY_storage_get_content(smx_storage_t storage) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static xbt_dict_t simcall_BODY_asr_get_properties(const char* name) {
+  
+inline static xbt_dict_t simcall_BODY_asr_get_properties(const char* name) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     return self->simcall.result.dp;
   }
 #ifdef HAVE_LATENCY_BOUND_TRACKING
-  inline static int simcall_BODY_comm_is_latency_bounded(smx_action_t comm) {
+  
+inline static int simcall_BODY_comm_is_latency_bounded(smx_action_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
 #endif
 
 #ifdef HAVE_TRACING
-  inline static void simcall_BODY_set_category(smx_action_t action, const char* category) {
+  
+inline static void simcall_BODY_set_category(smx_action_t action, const char* category) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
 #endif
 
 #ifdef HAVE_MC
-  inline static void* simcall_BODY_mc_snapshot() {
+  
+inline static void* simcall_BODY_mc_snapshot() {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.dp;
   }
-  inline static int simcall_BODY_mc_compare_snapshots(void* s1, void* s2) {
+  
+inline static int simcall_BODY_mc_compare_snapshots(void* s1, void* s2) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     }    
     return self->simcall.result.i;
   }
-  inline static int simcall_BODY_mc_random(int min, int max) {
+  
+inline static int simcall_BODY_mc_random(int min, int max) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */