Remove some most simcall HEADERs

diff --git a/src/simix/popping_accessors.h b/src/simix/popping_accessors.h
index ef08012..aa44bae 100644 (file)
--- a/src/simix/popping_accessors.h
+++ b/src/simix/popping_accessors.h
@@ -1882,43 +1882,8 @@ static inline void simcall_mc_random__set__result(smx_simcall_t simcall, int res
 
 /* The prototype of all simcall handlers, automatically generated for you */
 
 
 /* The prototype of all simcall handlers, automatically generated for you */
 

-smx_host_t simcall_HANDLER_host_get_by_name(smx_simcall_t simcall, const char* name);
-const char* simcall_HANDLER_host_get_name(smx_simcall_t simcall, smx_host_t host);
-void simcall_HANDLER_host_on(smx_simcall_t simcall, smx_host_t host);

 void simcall_HANDLER_host_off(smx_simcall_t simcall, smx_host_t host);
 void simcall_HANDLER_host_off(smx_simcall_t simcall, smx_host_t host);

-xbt_dict_t simcall_HANDLER_host_get_properties(smx_simcall_t simcall, smx_host_t host);
-int simcall_HANDLER_host_get_core(smx_simcall_t simcall, smx_host_t host);
-xbt_swag_t simcall_HANDLER_host_get_process_list(smx_simcall_t simcall, smx_host_t host);
-double simcall_HANDLER_host_get_speed(smx_simcall_t simcall, smx_host_t host);
-double simcall_HANDLER_host_get_available_speed(smx_simcall_t simcall, smx_host_t host);
-int simcall_HANDLER_host_get_state(smx_simcall_t simcall, smx_host_t host);
-double simcall_HANDLER_host_get_current_power_peak(smx_simcall_t simcall, smx_host_t host);
-double simcall_HANDLER_host_get_power_peak_at(smx_simcall_t simcall, smx_host_t host, int pstate_index);
-int simcall_HANDLER_host_get_nb_pstates(smx_simcall_t simcall, smx_host_t host);
-void simcall_HANDLER_host_set_power_peak_at(smx_simcall_t simcall, smx_host_t host, int pstate_index);
-double simcall_HANDLER_host_get_consumed_energy(smx_simcall_t simcall, smx_host_t host);
-smx_synchro_t simcall_HANDLER_host_execute(smx_simcall_t simcall, const char* name, smx_host_t host, double computation_amount, double priority, double bound, unsigned long affinity_mask);
-smx_synchro_t simcall_HANDLER_host_parallel_execute(smx_simcall_t simcall, const char* name, int host_nb, smx_host_t* host_list, double* computation_amount, double* communication_amount, double amount, double rate);
-void simcall_HANDLER_host_execution_destroy(smx_simcall_t simcall, smx_synchro_t execution);
-void simcall_HANDLER_host_execution_cancel(smx_simcall_t simcall, smx_synchro_t execution);
-double simcall_HANDLER_host_execution_get_remains(smx_simcall_t simcall, smx_synchro_t execution);
-e_smx_state_t simcall_HANDLER_host_execution_get_state(smx_simcall_t simcall, smx_synchro_t execution);
-void simcall_HANDLER_host_execution_set_priority(smx_simcall_t simcall, smx_synchro_t execution, double priority);
-void simcall_HANDLER_host_execution_set_bound(smx_simcall_t simcall, smx_synchro_t execution, double bound);
-void simcall_HANDLER_host_execution_set_affinity(smx_simcall_t simcall, smx_synchro_t execution, smx_host_t ws, unsigned long mask);

 void simcall_HANDLER_host_execution_wait(smx_simcall_t simcall, smx_synchro_t execution);
 void simcall_HANDLER_host_execution_wait(smx_simcall_t simcall, smx_synchro_t execution);

-xbt_dict_t simcall_HANDLER_host_get_mounted_storage_list(smx_simcall_t simcall, smx_host_t host);
-xbt_dynar_t simcall_HANDLER_host_get_attached_storage_list(smx_simcall_t simcall, smx_host_t host);
-void simcall_HANDLER_host_get_params(smx_simcall_t simcall, smx_host_t ind_vm, ws_params_t params);
-void simcall_HANDLER_host_set_params(smx_simcall_t simcall, smx_host_t ind_vm, ws_params_t params);
-smx_host_t simcall_HANDLER_vm_create(smx_simcall_t simcall, const char* name, smx_host_t ind_pm);
-void simcall_HANDLER_vm_start(smx_simcall_t simcall, smx_host_t ind_vm);
-int simcall_HANDLER_vm_get_state(smx_simcall_t simcall, smx_host_t ind_vm);
-void simcall_HANDLER_vm_migrate(smx_simcall_t simcall, smx_host_t ind_vm, smx_host_t ind_dst_pm);
-void* simcall_HANDLER_vm_get_pm(smx_simcall_t simcall, smx_host_t ind_vm);
-void simcall_HANDLER_vm_set_bound(smx_simcall_t simcall, smx_host_t ind_vm, double bound);
-void simcall_HANDLER_vm_set_affinity(smx_simcall_t simcall, smx_host_t ind_vm, smx_host_t ind_pm, unsigned long mask);
-void simcall_HANDLER_vm_destroy(smx_simcall_t simcall, smx_host_t ind_vm);

 void simcall_HANDLER_vm_suspend(smx_simcall_t simcall, smx_host_t ind_vm);
 void simcall_HANDLER_vm_resume(smx_simcall_t simcall, smx_host_t ind_vm);
 void simcall_HANDLER_vm_shutdown(smx_simcall_t simcall, smx_host_t ind_vm);
 void simcall_HANDLER_vm_suspend(smx_simcall_t simcall, smx_host_t ind_vm);
 void simcall_HANDLER_vm_resume(smx_simcall_t simcall, smx_host_t ind_vm);
 void simcall_HANDLER_vm_shutdown(smx_simcall_t simcall, smx_host_t ind_vm);


@@ -1927,59 +1892,27 @@ void simcall_HANDLER_vm_restore(smx_simcall_t simcall, smx_host_t ind_vm);
 void simcall_HANDLER_process_create(smx_simcall_t simcall, 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);
 void simcall_HANDLER_process_kill(smx_simcall_t simcall, smx_process_t process);
 void simcall_HANDLER_process_killall(smx_simcall_t simcall, int reset_pid);
 void simcall_HANDLER_process_create(smx_simcall_t simcall, 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);
 void simcall_HANDLER_process_kill(smx_simcall_t simcall, smx_process_t process);
 void simcall_HANDLER_process_killall(smx_simcall_t simcall, int reset_pid);

-void simcall_HANDLER_process_cleanup(smx_simcall_t simcall, smx_process_t process);

 void simcall_HANDLER_process_change_host(smx_simcall_t simcall, smx_process_t process, smx_host_t dest);
 void simcall_HANDLER_process_suspend(smx_simcall_t simcall, smx_process_t process);
 void simcall_HANDLER_process_resume(smx_simcall_t simcall, smx_process_t process);
 void simcall_HANDLER_process_change_host(smx_simcall_t simcall, smx_process_t process, smx_host_t dest);
 void simcall_HANDLER_process_suspend(smx_simcall_t simcall, smx_process_t process);
 void simcall_HANDLER_process_resume(smx_simcall_t simcall, smx_process_t process);

-int simcall_HANDLER_process_count(smx_simcall_t simcall);
-int simcall_HANDLER_process_get_PID(smx_simcall_t simcall, smx_process_t process);
-int simcall_HANDLER_process_get_PPID(smx_simcall_t simcall, smx_process_t process);
-void* simcall_HANDLER_process_get_data(smx_simcall_t simcall, smx_process_t process);
-void simcall_HANDLER_process_set_data(smx_simcall_t simcall, smx_process_t process, void* data);
-smx_host_t simcall_HANDLER_process_get_host(smx_simcall_t simcall, smx_process_t process);
-const char* simcall_HANDLER_process_get_name(smx_simcall_t simcall, smx_process_t process);
-int simcall_HANDLER_process_is_suspended(smx_simcall_t simcall, smx_process_t process);
-xbt_dict_t simcall_HANDLER_process_get_properties(smx_simcall_t simcall, smx_process_t process);

 void simcall_HANDLER_process_join(smx_simcall_t simcall, smx_process_t process, double timeout);
 void simcall_HANDLER_process_sleep(smx_simcall_t simcall, double duration);
 void simcall_HANDLER_process_join(smx_simcall_t simcall, smx_process_t process, double timeout);
 void simcall_HANDLER_process_sleep(smx_simcall_t simcall, double duration);

-void simcall_HANDLER_process_on_exit(smx_simcall_t simcall, smx_process_t process, int_f_pvoid_pvoid_t fun, void* data);
-void simcall_HANDLER_process_auto_restart_set(smx_simcall_t simcall, smx_process_t process, int auto_restart);

 smx_process_t simcall_HANDLER_process_restart(smx_simcall_t simcall, smx_process_t process);
 smx_process_t simcall_HANDLER_process_restart(smx_simcall_t simcall, smx_process_t process);

-smx_rdv_t simcall_HANDLER_rdv_create(smx_simcall_t simcall, const char* name);
-void simcall_HANDLER_rdv_destroy(smx_simcall_t simcall, smx_rdv_t rdv);
-unsigned int simcall_HANDLER_rdv_comm_count_by_host(smx_simcall_t simcall, smx_rdv_t rdv, smx_host_t host);
-smx_synchro_t simcall_HANDLER_rdv_get_head(smx_simcall_t simcall, smx_rdv_t rdv);
-void simcall_HANDLER_rdv_set_receiver(smx_simcall_t simcall, smx_rdv_t rdv, smx_process_t receiver);
-smx_process_t simcall_HANDLER_rdv_get_receiver(smx_simcall_t simcall, smx_rdv_t rdv);

 smx_synchro_t simcall_HANDLER_comm_iprobe(smx_simcall_t simcall, smx_rdv_t rdv, int type, int src, int tag, simix_match_func_t match_fun, void* data);
 void simcall_HANDLER_comm_send(smx_simcall_t simcall, 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_synchro_t simcall_HANDLER_comm_isend(smx_simcall_t simcall, 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);
 void simcall_HANDLER_comm_recv(smx_simcall_t simcall, 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_synchro_t simcall_HANDLER_comm_irecv(smx_simcall_t simcall, 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_synchro_t simcall_HANDLER_comm_iprobe(smx_simcall_t simcall, smx_rdv_t rdv, int type, int src, int tag, simix_match_func_t match_fun, void* data);
 void simcall_HANDLER_comm_send(smx_simcall_t simcall, 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_synchro_t simcall_HANDLER_comm_isend(smx_simcall_t simcall, 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);
 void simcall_HANDLER_comm_recv(smx_simcall_t simcall, 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_synchro_t simcall_HANDLER_comm_irecv(smx_simcall_t simcall, 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);

-void simcall_HANDLER_comm_cancel(smx_simcall_t simcall, smx_synchro_t comm);

 void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t comms);
 void simcall_HANDLER_comm_wait(smx_simcall_t simcall, smx_synchro_t comm, double timeout);
 void simcall_HANDLER_comm_test(smx_simcall_t simcall, smx_synchro_t comm);
 void simcall_HANDLER_comm_testany(smx_simcall_t simcall, xbt_dynar_t comms);
 void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t comms);
 void simcall_HANDLER_comm_wait(smx_simcall_t simcall, smx_synchro_t comm, double timeout);
 void simcall_HANDLER_comm_test(smx_simcall_t simcall, smx_synchro_t comm);
 void simcall_HANDLER_comm_testany(smx_simcall_t simcall, xbt_dynar_t comms);

-double simcall_HANDLER_comm_get_remains(smx_simcall_t simcall, smx_synchro_t comm);
-e_smx_state_t simcall_HANDLER_comm_get_state(smx_simcall_t simcall, smx_synchro_t comm);
-void* simcall_HANDLER_comm_get_src_data(smx_simcall_t simcall, smx_synchro_t comm);
-void* simcall_HANDLER_comm_get_dst_data(smx_simcall_t simcall, smx_synchro_t comm);
-smx_process_t simcall_HANDLER_comm_get_src_proc(smx_simcall_t simcall, smx_synchro_t comm);
-smx_process_t simcall_HANDLER_comm_get_dst_proc(smx_simcall_t simcall, smx_synchro_t comm);

 smx_mutex_t simcall_HANDLER_mutex_init(smx_simcall_t simcall);
 smx_mutex_t simcall_HANDLER_mutex_init(smx_simcall_t simcall);

-void simcall_HANDLER_mutex_destroy(smx_simcall_t simcall, smx_mutex_t mutex);

 void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex);
 void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex);

-
+int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex);

 void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex);
 void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex);

-smx_cond_t simcall_HANDLER_cond_init(smx_simcall_t simcall);
-void simcall_HANDLER_cond_destroy(smx_simcall_t simcall, smx_cond_t cond);
-void simcall_HANDLER_cond_signal(smx_simcall_t simcall, smx_cond_t cond);

 void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex);
 void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);
 void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex);
 void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);

-void simcall_HANDLER_cond_broadcast(smx_simcall_t simcall, smx_cond_t cond);
-smx_sem_t simcall_HANDLER_sem_init(smx_simcall_t simcall, unsigned int capacity);
-void simcall_HANDLER_sem_destroy(smx_simcall_t simcall, smx_sem_t sem);

 void simcall_HANDLER_sem_release(smx_simcall_t simcall, smx_sem_t sem);
 int simcall_HANDLER_sem_would_block(smx_simcall_t simcall, smx_sem_t sem);
 void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem);
 void simcall_HANDLER_sem_release(smx_simcall_t simcall, smx_sem_t sem);
 int simcall_HANDLER_sem_would_block(smx_simcall_t simcall, smx_sem_t sem);
 void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem);


@@ -1989,7 +1922,6 @@ void simcall_HANDLER_file_read(smx_simcall_t simcall, smx_file_t fd, sg_size_t s
 void simcall_HANDLER_file_write(smx_simcall_t simcall, smx_file_t fd, sg_size_t size, smx_host_t host);
 void simcall_HANDLER_file_open(smx_simcall_t simcall, const char* fullpath, smx_host_t host);
 void simcall_HANDLER_file_close(smx_simcall_t simcall, smx_file_t fd, smx_host_t host);
 void simcall_HANDLER_file_write(smx_simcall_t simcall, smx_file_t fd, sg_size_t size, smx_host_t host);
 void simcall_HANDLER_file_open(smx_simcall_t simcall, const char* fullpath, smx_host_t host);
 void simcall_HANDLER_file_close(smx_simcall_t simcall, smx_file_t fd, smx_host_t host);

-int simcall_HANDLER_file_unlink(smx_simcall_t simcall, smx_file_t fd, smx_host_t host);

 sg_size_t simcall_HANDLER_file_get_size(smx_simcall_t simcall, smx_file_t fd);
 sg_size_t simcall_HANDLER_file_tell(smx_simcall_t simcall, smx_file_t fd);
 int simcall_HANDLER_file_seek(smx_simcall_t simcall, smx_file_t fd, sg_offset_t offset, int origin);
 sg_size_t simcall_HANDLER_file_get_size(smx_simcall_t simcall, smx_file_t fd);
 sg_size_t simcall_HANDLER_file_tell(smx_simcall_t simcall, smx_file_t fd);
 int simcall_HANDLER_file_seek(smx_simcall_t simcall, smx_file_t fd, sg_offset_t offset, int origin);


@@ -1997,15 +1929,13 @@ xbt_dynar_t simcall_HANDLER_file_get_info(smx_simcall_t simcall, smx_file_t fd);
 int simcall_HANDLER_file_move(smx_simcall_t simcall, smx_file_t fd, const char* fullpath);
 sg_size_t simcall_HANDLER_storage_get_free_size(smx_simcall_t simcall, smx_storage_t storage);
 sg_size_t simcall_HANDLER_storage_get_used_size(smx_simcall_t simcall, smx_storage_t name);
 int simcall_HANDLER_file_move(smx_simcall_t simcall, smx_file_t fd, const char* fullpath);
 sg_size_t simcall_HANDLER_storage_get_free_size(smx_simcall_t simcall, smx_storage_t storage);
 sg_size_t simcall_HANDLER_storage_get_used_size(smx_simcall_t simcall, smx_storage_t name);

-xbt_dict_t simcall_HANDLER_storage_get_properties(smx_simcall_t simcall, smx_storage_t storage);
-xbt_dict_t simcall_HANDLER_storage_get_content(smx_simcall_t simcall, smx_storage_t storage);

 xbt_dict_t simcall_HANDLER_asr_get_properties(smx_simcall_t simcall, const char* name);
 #ifdef HAVE_LATENCY_BOUND_TRACKING
 xbt_dict_t simcall_HANDLER_asr_get_properties(smx_simcall_t simcall, const char* name);
 #ifdef HAVE_LATENCY_BOUND_TRACKING

-int simcall_HANDLER_comm_is_latency_bounded(smx_simcall_t simcall, smx_synchro_t comm);
+

 #endif
 
 #ifdef HAVE_TRACING
 #endif
 
 #ifdef HAVE_TRACING

-void simcall_HANDLER_set_category(smx_simcall_t simcall, smx_synchro_t synchro, const char* category);
+

 #endif
 
 #ifdef HAVE_MC
 #endif
 
 #ifdef HAVE_MC

diff --git a/src/simix/popping_bodies.c b/src/simix/popping_bodies.c
index f0effd3..fd28480 100644 (file)
--- a/src/simix/popping_bodies.c
+++ b/src/simix/popping_bodies.c
@@ -21,7 +21,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_get_by_name(&self->simcall, name);
+    if (0) SIMIX_host_get_by_name(name);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_BY_NAME;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_BY_NAME;


@@ -42,7 +42,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_get_name(&self->simcall, host);
+    if (0) SIMIX_host_get_name(host);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_NAME;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_NAME;


@@ -63,7 +63,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_on(&self->simcall, host);
+    if (0) SIMIX_host_on(host);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_ON;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_ON;


@@ -105,7 +105,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_get_properties(&self->simcall, host);
+    if (0) SIMIX_host_get_properties(host);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_PROPERTIES;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_PROPERTIES;


@@ -126,7 +126,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_get_core(&self->simcall, host);
+    if (0) SIMIX_host_get_core(host);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_CORE;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_CORE;


@@ -147,7 +147,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_get_process_list(&self->simcall, host);
+    if (0) SIMIX_host_get_process_list(host);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_PROCESS_LIST;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_PROCESS_LIST;


@@ -168,7 +168,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_get_speed(&self->simcall, host);
+    if (0) SIMIX_host_get_speed(host);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_SPEED;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_SPEED;


@@ -189,7 +189,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_get_available_speed(&self->simcall, host);
+    if (0) SIMIX_host_get_available_speed(host);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_AVAILABLE_SPEED;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_AVAILABLE_SPEED;


@@ -210,7 +210,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_get_state(&self->simcall, host);
+    if (0) SIMIX_host_get_state(host);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_STATE;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_STATE;


@@ -231,7 +231,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_get_current_power_peak(&self->simcall, host);
+    if (0) SIMIX_host_get_current_power_peak(host);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_CURRENT_POWER_PEAK;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_CURRENT_POWER_PEAK;


@@ -252,7 +252,7 @@ inline static double simcall_BODY_host_get_power_peak_at(smx_host_t host, int ps
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_get_power_peak_at(&self->simcall, host, pstate_index);
+    if (0) SIMIX_host_get_power_peak_at(host, pstate_index);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_POWER_PEAK_AT;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_POWER_PEAK_AT;


@@ -274,7 +274,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_get_nb_pstates(&self->simcall, host);
+    if (0) SIMIX_host_get_nb_pstates(host);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_NB_PSTATES;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_NB_PSTATES;


@@ -295,7 +295,7 @@ inline static void simcall_BODY_host_set_power_peak_at(smx_host_t host, int psta
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_set_power_peak_at(&self->simcall, host, pstate_index);
+    if (0) SIMIX_host_set_power_peak_at(host, pstate_index);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_SET_POWER_PEAK_AT;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_SET_POWER_PEAK_AT;


@@ -317,7 +317,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_get_consumed_energy(&self->simcall, host);
+    if (0) SIMIX_host_get_consumed_energy(host);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_CONSUMED_ENERGY;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_CONSUMED_ENERGY;


@@ -338,7 +338,7 @@ inline static smx_synchro_t simcall_BODY_host_execute(const char* name, smx_host
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_execute(&self->simcall, name, host, computation_amount, priority, bound, affinity_mask);
+    if (0) SIMIX_host_execute(name, host, computation_amount, priority, bound, affinity_mask);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTE;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTE;


@@ -364,7 +364,7 @@ inline static smx_synchro_t simcall_BODY_host_parallel_execute(const char* name,
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_parallel_execute(&self->simcall, name, host_nb, host_list, computation_amount, communication_amount, amount, rate);
+    if (0) SIMIX_host_parallel_execute(name, host_nb, host_list, computation_amount, communication_amount, amount, rate);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_PARALLEL_EXECUTE;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_PARALLEL_EXECUTE;


@@ -391,7 +391,7 @@ inline static void simcall_BODY_host_execution_destroy(smx_synchro_t execution)
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_execution_destroy(&self->simcall, execution);
+    if (0) SIMIX_host_execution_destroy(execution);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTION_DESTROY;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTION_DESTROY;


@@ -412,7 +412,7 @@ inline static void simcall_BODY_host_execution_cancel(smx_synchro_t execution) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_execution_cancel(&self->simcall, execution);
+    if (0) SIMIX_host_execution_cancel(execution);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTION_CANCEL;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTION_CANCEL;


@@ -433,7 +433,7 @@ inline static double simcall_BODY_host_execution_get_remains(smx_synchro_t execu
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_execution_get_remains(&self->simcall, execution);
+    if (0) SIMIX_host_execution_get_remains(execution);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTION_GET_REMAINS;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTION_GET_REMAINS;


@@ -454,7 +454,7 @@ inline static e_smx_state_t simcall_BODY_host_execution_get_state(smx_synchro_t
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_execution_get_state(&self->simcall, execution);
+    if (0) SIMIX_host_execution_get_state(execution);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTION_GET_STATE;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTION_GET_STATE;


@@ -475,7 +475,7 @@ inline static void simcall_BODY_host_execution_set_priority(smx_synchro_t execut
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_execution_set_priority(&self->simcall, execution, priority);
+    if (0) SIMIX_host_execution_set_priority(execution, priority);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTION_SET_PRIORITY;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTION_SET_PRIORITY;


@@ -497,7 +497,7 @@ inline static void simcall_BODY_host_execution_set_bound(smx_synchro_t execution
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_execution_set_bound(&self->simcall, execution, bound);
+    if (0) SIMIX_host_execution_set_bound(execution, bound);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTION_SET_BOUND;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTION_SET_BOUND;


@@ -519,7 +519,7 @@ inline static void simcall_BODY_host_execution_set_affinity(smx_synchro_t execut
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_execution_set_affinity(&self->simcall, execution, ws, mask);
+    if (0) SIMIX_host_execution_set_affinity(execution, ws, mask);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTION_SET_AFFINITY;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_EXECUTION_SET_AFFINITY;


@@ -563,7 +563,7 @@ inline static xbt_dict_t simcall_BODY_host_get_mounted_storage_list(smx_host_t h
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_get_mounted_storage_list(&self->simcall, host);
+    if (0) SIMIX_host_get_mounted_storage_list(host);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_MOUNTED_STORAGE_LIST;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_MOUNTED_STORAGE_LIST;


@@ -584,7 +584,7 @@ inline static xbt_dynar_t simcall_BODY_host_get_attached_storage_list(smx_host_t
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_get_attached_storage_list(&self->simcall, host);
+    if (0) SIMIX_host_get_attached_storage_list(host);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_ATTACHED_STORAGE_LIST;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_ATTACHED_STORAGE_LIST;


@@ -605,7 +605,7 @@ inline static void simcall_BODY_host_get_params(smx_host_t ind_vm, ws_params_t p
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_get_params(&self->simcall, ind_vm, params);
+    if (0) SIMIX_host_get_params(ind_vm, params);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_PARAMS;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_GET_PARAMS;


@@ -627,7 +627,7 @@ inline static void simcall_BODY_host_set_params(smx_host_t ind_vm, ws_params_t p
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_host_set_params(&self->simcall, ind_vm, params);
+    if (0) SIMIX_host_set_params(ind_vm, params);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_SET_PARAMS;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_HOST_SET_PARAMS;


@@ -649,7 +649,7 @@ inline static smx_host_t simcall_BODY_vm_create(const char* name, smx_host_t ind
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_vm_create(&self->simcall, name, ind_pm);
+    if (0) SIMIX_vm_create(name, ind_pm);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_CREATE;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_CREATE;


@@ -671,7 +671,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_vm_start(&self->simcall, ind_vm);
+    if (0) SIMIX_vm_start(ind_vm);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_START;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_START;


@@ -692,7 +692,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_vm_get_state(&self->simcall, ind_vm);
+    if (0) SIMIX_vm_get_state(ind_vm);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_GET_STATE;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_GET_STATE;


@@ -713,7 +713,7 @@ inline static void simcall_BODY_vm_migrate(smx_host_t ind_vm, smx_host_t ind_dst
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_vm_migrate(&self->simcall, ind_vm, ind_dst_pm);
+    if (0) SIMIX_vm_migrate(ind_vm, ind_dst_pm);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_MIGRATE;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_MIGRATE;


@@ -735,7 +735,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_vm_get_pm(&self->simcall, ind_vm);
+    if (0) SIMIX_vm_get_pm(ind_vm);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_GET_PM;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_GET_PM;


@@ -756,7 +756,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_vm_set_bound(&self->simcall, ind_vm, bound);
+    if (0) SIMIX_vm_set_bound(ind_vm, bound);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_SET_BOUND;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_SET_BOUND;


@@ -778,7 +778,7 @@ inline static void simcall_BODY_vm_set_affinity(smx_host_t ind_vm, smx_host_t in
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_vm_set_affinity(&self->simcall, ind_vm, ind_pm, mask);
+    if (0) SIMIX_vm_set_affinity(ind_vm, ind_pm, mask);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_SET_AFFINITY;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_SET_AFFINITY;


@@ -801,7 +801,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_vm_destroy(&self->simcall, ind_vm);
+    if (0) SIMIX_vm_destroy(ind_vm);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_DESTROY;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_VM_DESTROY;


@@ -999,7 +999,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_process_cleanup(&self->simcall, process);
+    if (0) SIMIX_process_cleanup(process);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_CLEANUP;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_CLEANUP;


@@ -1084,7 +1084,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_process_count(&self->simcall);
+    if (0) SIMIX_process_count();

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_COUNT;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_COUNT;


@@ -1105,7 +1105,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_process_get_PID(&self->simcall, process);
+    if (0) SIMIX_process_get_PID(process);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_GET_PID;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_GET_PID;


@@ -1126,7 +1126,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_process_get_PPID(&self->simcall, process);
+    if (0) SIMIX_process_get_PPID(process);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_GET_PPID;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_GET_PPID;


@@ -1147,7 +1147,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_process_get_data(&self->simcall, process);
+    if (0) SIMIX_process_get_data(process);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_GET_DATA;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_GET_DATA;


@@ -1168,7 +1168,7 @@ inline static void simcall_BODY_process_set_data(smx_process_t process, void* da
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_process_set_data(&self->simcall, process, data);
+    if (0) SIMIX_process_set_data(process, data);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_SET_DATA;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_SET_DATA;


@@ -1190,7 +1190,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_process_get_host(&self->simcall, process);
+    if (0) SIMIX_process_get_host(process);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_GET_HOST;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_GET_HOST;


@@ -1211,7 +1211,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_process_get_name(&self->simcall, process);
+    if (0) SIMIX_process_get_name(process);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_GET_NAME;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_GET_NAME;


@@ -1232,7 +1232,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_process_is_suspended(&self->simcall, process);
+    if (0) SIMIX_process_is_suspended(process);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_IS_SUSPENDED;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_IS_SUSPENDED;


@@ -1253,7 +1253,7 @@ inline static xbt_dict_t simcall_BODY_process_get_properties(smx_process_t proce
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_process_get_properties(&self->simcall, process);
+    if (0) SIMIX_process_get_properties(process);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_GET_PROPERTIES;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_GET_PROPERTIES;


@@ -1317,7 +1317,7 @@ inline static void simcall_BODY_process_on_exit(smx_process_t process, int_f_pvo
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_process_on_exit(&self->simcall, process, fun, data);
+    if (0) SIMIX_process_on_exit(process, fun, data);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_ON_EXIT;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_ON_EXIT;


@@ -1340,7 +1340,7 @@ inline static void simcall_BODY_process_auto_restart_set(smx_process_t process,
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_process_auto_restart_set(&self->simcall, process, auto_restart);
+    if (0) SIMIX_process_auto_restart_set(process, auto_restart);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_AUTO_RESTART_SET;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_PROCESS_AUTO_RESTART_SET;


@@ -1383,7 +1383,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_rdv_create(&self->simcall, name);
+    if (0) SIMIX_rdv_create(name);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_RDV_CREATE;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_RDV_CREATE;


@@ -1404,7 +1404,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_rdv_destroy(&self->simcall, rdv);
+    if (0) SIMIX_rdv_destroy(rdv);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_RDV_DESTROY;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_RDV_DESTROY;


@@ -1425,7 +1425,7 @@ inline static unsigned int simcall_BODY_rdv_comm_count_by_host(smx_rdv_t rdv, sm
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_rdv_comm_count_by_host(&self->simcall, rdv, host);
+    if (0) SIMIX_rdv_comm_count_by_host(rdv, host);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_RDV_COMM_COUNT_BY_HOST;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_RDV_COMM_COUNT_BY_HOST;


@@ -1447,7 +1447,7 @@ inline static smx_synchro_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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_rdv_get_head(&self->simcall, rdv);
+    if (0) SIMIX_rdv_get_head(rdv);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_RDV_GET_HEAD;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_RDV_GET_HEAD;


@@ -1468,7 +1468,7 @@ inline static void simcall_BODY_rdv_set_receiver(smx_rdv_t rdv, smx_process_t re
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_rdv_set_receiver(&self->simcall, rdv, receiver);
+    if (0) SIMIX_rdv_set_receiver(rdv, receiver);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_RDV_SET_RECEIVER;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_RDV_SET_RECEIVER;


@@ -1490,7 +1490,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_rdv_get_receiver(&self->simcall, rdv);
+    if (0) SIMIX_rdv_get_receiver(rdv);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_RDV_GET_RECEIVER;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_RDV_GET_RECEIVER;


@@ -1653,7 +1653,7 @@ inline static void simcall_BODY_comm_cancel(smx_synchro_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_comm_cancel(&self->simcall, comm);
+    if (0) SIMIX_comm_cancel(comm);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_CANCEL;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_CANCEL;


@@ -1759,7 +1759,7 @@ inline static double simcall_BODY_comm_get_remains(smx_synchro_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_comm_get_remains(&self->simcall, comm);
+    if (0) SIMIX_comm_get_remains(comm);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_GET_REMAINS;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_GET_REMAINS;


@@ -1780,7 +1780,7 @@ inline static e_smx_state_t simcall_BODY_comm_get_state(smx_synchro_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_comm_get_state(&self->simcall, comm);
+    if (0) SIMIX_comm_get_state(comm);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_GET_STATE;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_GET_STATE;


@@ -1801,7 +1801,7 @@ inline static void* simcall_BODY_comm_get_src_data(smx_synchro_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_comm_get_src_data(&self->simcall, comm);
+    if (0) SIMIX_comm_get_src_data(comm);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_GET_SRC_DATA;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_GET_SRC_DATA;


@@ -1822,7 +1822,7 @@ inline static void* simcall_BODY_comm_get_dst_data(smx_synchro_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_comm_get_dst_data(&self->simcall, comm);
+    if (0) SIMIX_comm_get_dst_data(comm);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_GET_DST_DATA;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_GET_DST_DATA;


@@ -1843,7 +1843,7 @@ inline static smx_process_t simcall_BODY_comm_get_src_proc(smx_synchro_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_comm_get_src_proc(&self->simcall, comm);
+    if (0) SIMIX_comm_get_src_proc(comm);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_GET_SRC_PROC;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_GET_SRC_PROC;


@@ -1864,7 +1864,7 @@ inline static smx_process_t simcall_BODY_comm_get_dst_proc(smx_synchro_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_comm_get_dst_proc(&self->simcall, comm);
+    if (0) SIMIX_comm_get_dst_proc(comm);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_GET_DST_PROC;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_GET_DST_PROC;


@@ -1906,7 +1906,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_mutex_destroy(&self->simcall, mutex);
+    if (0) SIMIX_mutex_destroy(mutex);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_MUTEX_DESTROY;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_MUTEX_DESTROY;


@@ -1948,7 +1948,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_mutex_trylock(mutex);
+    if (0) simcall_HANDLER_mutex_trylock(&self->simcall, mutex);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_MUTEX_TRYLOCK;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_MUTEX_TRYLOCK;


@@ -1990,7 +1990,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_cond_init(&self->simcall);
+    if (0) SIMIX_cond_init();

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COND_INIT;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COND_INIT;


@@ -2011,7 +2011,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_cond_destroy(&self->simcall, cond);
+    if (0) SIMIX_cond_destroy(cond);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COND_DESTROY;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COND_DESTROY;


@@ -2032,7 +2032,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_cond_signal(&self->simcall, cond);
+    if (0) SIMIX_cond_signal(cond);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COND_SIGNAL;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COND_SIGNAL;


@@ -2098,7 +2098,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_cond_broadcast(&self->simcall, cond);
+    if (0) SIMIX_cond_broadcast(cond);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COND_BROADCAST;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COND_BROADCAST;


@@ -2119,7 +2119,7 @@ inline static smx_sem_t simcall_BODY_sem_init(unsigned int capacity) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_sem_init(&self->simcall, capacity);
+    if (0) SIMIX_sem_init(capacity);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_SEM_INIT;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_SEM_INIT;


@@ -2140,7 +2140,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_sem_destroy(&self->simcall, sem);
+    if (0) SIMIX_sem_destroy(sem);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_SEM_DESTROY;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_SEM_DESTROY;


@@ -2357,7 +2357,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_file_unlink(&self->simcall, fd, host);
+    if (0) SIMIX_file_unlink(fd, host);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_FILE_UNLINK;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_FILE_UNLINK;


@@ -2529,7 +2529,7 @@ inline static xbt_dict_t simcall_BODY_storage_get_properties(smx_storage_t stora
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_storage_get_properties(&self->simcall, storage);
+    if (0) SIMIX_storage_get_properties(storage);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_STORAGE_GET_PROPERTIES;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_STORAGE_GET_PROPERTIES;


@@ -2550,7 +2550,7 @@ 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 */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_storage_get_content(&self->simcall, storage);
+    if (0) SIMIX_storage_get_content(storage);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_STORAGE_GET_CONTENT;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_STORAGE_GET_CONTENT;


@@ -2593,7 +2593,7 @@ inline static int simcall_BODY_comm_is_latency_bounded(smx_synchro_t comm) {
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_comm_is_latency_bounded(&self->simcall, comm);
+    if (0) SIMIX_comm_is_latency_bounded(comm);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_IS_LATENCY_BOUNDED;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_COMM_IS_LATENCY_BOUNDED;


@@ -2617,7 +2617,7 @@ inline static void simcall_BODY_set_category(smx_synchro_t synchro, const char*
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */
     smx_process_t self = SIMIX_process_self();
 
     /* Go to that function to follow the code flow through the simcall barrier */

-    if (0) simcall_HANDLER_set_category(&self->simcall, synchro, category);
+    if (0) SIMIX_set_category(synchro, category);

     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_SET_CATEGORY;
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_SET_CATEGORY;

diff --git a/src/simix/popping_generated.c b/src/simix/popping_generated.c
index a6cfb76..e4cc8a5 100644 (file)
--- a/src/simix/popping_generated.c
+++ b/src/simix/popping_generated.c
@@ -168,17 +168,17 @@ void SIMIX_simcall_handle(smx_simcall_t simcall, int value) {
     return;
   switch (simcall->call) {
 case SIMCALL_HOST_GET_BY_NAME:
     return;
   switch (simcall->call) {
 case SIMCALL_HOST_GET_BY_NAME:

-      simcall->result.dp = simcall_HANDLER_host_get_by_name(simcall ,  simcall->args[0].cc);
+      simcall->result.dp = SIMIX_host_get_by_name( simcall->args[0].cc);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_NAME:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_NAME:

-      simcall->result.cc = simcall_HANDLER_host_get_name(simcall , (smx_host_t) simcall->args[0].dp);
+      simcall->result.cc = SIMIX_host_get_name((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_ON:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_ON:

-       simcall_HANDLER_host_on(simcall , (smx_host_t) simcall->args[0].dp);
+       SIMIX_host_on((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -188,102 +188,102 @@ case SIMCALL_HOST_OFF:
       break;  
 
 case SIMCALL_HOST_GET_PROPERTIES:
       break;  
 
 case SIMCALL_HOST_GET_PROPERTIES:

-      simcall->result.dp = simcall_HANDLER_host_get_properties(simcall , (smx_host_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_host_get_properties((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_CORE:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_CORE:

-      simcall->result.i = simcall_HANDLER_host_get_core(simcall , (smx_host_t) simcall->args[0].dp);
+      simcall->result.i = SIMIX_host_get_core((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_PROCESS_LIST:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_PROCESS_LIST:

-      simcall->result.dp = simcall_HANDLER_host_get_process_list(simcall , (smx_host_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_host_get_process_list((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_SPEED:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_SPEED:

-      simcall->result.d = simcall_HANDLER_host_get_speed(simcall , (smx_host_t) simcall->args[0].dp);
+      simcall->result.d = SIMIX_host_get_speed((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_AVAILABLE_SPEED:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_AVAILABLE_SPEED:

-      simcall->result.d = simcall_HANDLER_host_get_available_speed(simcall , (smx_host_t) simcall->args[0].dp);
+      simcall->result.d = SIMIX_host_get_available_speed((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_STATE:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_STATE:

-      simcall->result.i = simcall_HANDLER_host_get_state(simcall , (smx_host_t) simcall->args[0].dp);
+      simcall->result.i = SIMIX_host_get_state((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_CURRENT_POWER_PEAK:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_CURRENT_POWER_PEAK:

-      simcall->result.d = simcall_HANDLER_host_get_current_power_peak(simcall , (smx_host_t) simcall->args[0].dp);
+      simcall->result.d = SIMIX_host_get_current_power_peak((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_POWER_PEAK_AT:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_POWER_PEAK_AT:

-      simcall->result.d = simcall_HANDLER_host_get_power_peak_at(simcall , (smx_host_t) simcall->args[0].dp,  simcall->args[1].i);
+      simcall->result.d = SIMIX_host_get_power_peak_at((smx_host_t) simcall->args[0].dp, simcall->args[1].i);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_NB_PSTATES:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_NB_PSTATES:

-      simcall->result.i = simcall_HANDLER_host_get_nb_pstates(simcall , (smx_host_t) simcall->args[0].dp);
+      simcall->result.i = SIMIX_host_get_nb_pstates((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_SET_POWER_PEAK_AT:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_SET_POWER_PEAK_AT:

-       simcall_HANDLER_host_set_power_peak_at(simcall , (smx_host_t) simcall->args[0].dp,  simcall->args[1].i);
+       SIMIX_host_set_power_peak_at((smx_host_t) simcall->args[0].dp, simcall->args[1].i);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_CONSUMED_ENERGY:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_CONSUMED_ENERGY:

-      simcall->result.d = simcall_HANDLER_host_get_consumed_energy(simcall , (smx_host_t) simcall->args[0].dp);
+      simcall->result.d = SIMIX_host_get_consumed_energy((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTE:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTE:

-      simcall->result.dp = simcall_HANDLER_host_execute(simcall ,  simcall->args[0].cc, (smx_host_t) simcall->args[1].dp,  simcall->args[2].d,  simcall->args[3].d,  simcall->args[4].d,  simcall->args[5].ul);
+      simcall->result.dp = SIMIX_host_execute( simcall->args[0].cc,(smx_host_t) simcall->args[1].dp, simcall->args[2].d, simcall->args[3].d, simcall->args[4].d, simcall->args[5].ul);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_PARALLEL_EXECUTE:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_PARALLEL_EXECUTE:

-      simcall->result.dp = simcall_HANDLER_host_parallel_execute(simcall ,  simcall->args[0].cc,  simcall->args[1].i, (smx_host_t*) simcall->args[2].dp, (double*) simcall->args[3].dp, (double*) simcall->args[4].dp,  simcall->args[5].d,  simcall->args[6].d);
+      simcall->result.dp = SIMIX_host_parallel_execute( simcall->args[0].cc, simcall->args[1].i,(smx_host_t*) simcall->args[2].dp,(double*) simcall->args[3].dp,(double*) simcall->args[4].dp, simcall->args[5].d, simcall->args[6].d);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTION_DESTROY:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTION_DESTROY:

-       simcall_HANDLER_host_execution_destroy(simcall , (smx_synchro_t) simcall->args[0].dp);
+       SIMIX_host_execution_destroy((smx_synchro_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTION_CANCEL:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTION_CANCEL:

-       simcall_HANDLER_host_execution_cancel(simcall , (smx_synchro_t) simcall->args[0].dp);
+       SIMIX_host_execution_cancel((smx_synchro_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTION_GET_REMAINS:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTION_GET_REMAINS:

-      simcall->result.d = simcall_HANDLER_host_execution_get_remains(simcall , (smx_synchro_t) simcall->args[0].dp);
+      simcall->result.d = SIMIX_host_execution_get_remains((smx_synchro_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTION_GET_STATE:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTION_GET_STATE:

-      simcall->result.i = simcall_HANDLER_host_execution_get_state(simcall , (smx_synchro_t) simcall->args[0].dp);
+      simcall->result.i = SIMIX_host_execution_get_state((smx_synchro_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTION_SET_PRIORITY:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTION_SET_PRIORITY:

-       simcall_HANDLER_host_execution_set_priority(simcall , (smx_synchro_t) simcall->args[0].dp,  simcall->args[1].d);
+       SIMIX_host_execution_set_priority((smx_synchro_t) simcall->args[0].dp, simcall->args[1].d);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTION_SET_BOUND:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTION_SET_BOUND:

-       simcall_HANDLER_host_execution_set_bound(simcall , (smx_synchro_t) simcall->args[0].dp,  simcall->args[1].d);
+       SIMIX_host_execution_set_bound((smx_synchro_t) simcall->args[0].dp, simcall->args[1].d);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTION_SET_AFFINITY:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_EXECUTION_SET_AFFINITY:

-       simcall_HANDLER_host_execution_set_affinity(simcall , (smx_synchro_t) simcall->args[0].dp, (smx_host_t) simcall->args[1].dp,  simcall->args[2].ul);
+       SIMIX_host_execution_set_affinity((smx_synchro_t) simcall->args[0].dp,(smx_host_t) simcall->args[1].dp, simcall->args[2].ul);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -292,62 +292,62 @@ case SIMCALL_HOST_EXECUTION_WAIT:
        break;  
 
 case SIMCALL_HOST_GET_MOUNTED_STORAGE_LIST:
        break;  
 
 case SIMCALL_HOST_GET_MOUNTED_STORAGE_LIST:

-      simcall->result.dp = simcall_HANDLER_host_get_mounted_storage_list(simcall , (smx_host_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_host_get_mounted_storage_list((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_ATTACHED_STORAGE_LIST:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_ATTACHED_STORAGE_LIST:

-      simcall->result.dp = simcall_HANDLER_host_get_attached_storage_list(simcall , (smx_host_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_host_get_attached_storage_list((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_PARAMS:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_GET_PARAMS:

-       simcall_HANDLER_host_get_params(simcall , (smx_host_t) simcall->args[0].dp, (ws_params_t) simcall->args[1].dp);
+       SIMIX_host_get_params((smx_host_t) simcall->args[0].dp,(ws_params_t) simcall->args[1].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_SET_PARAMS:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_HOST_SET_PARAMS:

-       simcall_HANDLER_host_set_params(simcall , (smx_host_t) simcall->args[0].dp, (ws_params_t) simcall->args[1].dp);
+       SIMIX_host_set_params((smx_host_t) simcall->args[0].dp,(ws_params_t) simcall->args[1].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_CREATE:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_CREATE:

-      simcall->result.dp = simcall_HANDLER_vm_create(simcall ,  simcall->args[0].cc, (smx_host_t) simcall->args[1].dp);
+      simcall->result.dp = SIMIX_vm_create( simcall->args[0].cc,(smx_host_t) simcall->args[1].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_START:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_START:

-       simcall_HANDLER_vm_start(simcall , (smx_host_t) simcall->args[0].dp);
+       SIMIX_vm_start((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_GET_STATE:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_GET_STATE:

-      simcall->result.i = simcall_HANDLER_vm_get_state(simcall , (smx_host_t) simcall->args[0].dp);
+      simcall->result.i = SIMIX_vm_get_state((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_MIGRATE:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_MIGRATE:

-       simcall_HANDLER_vm_migrate(simcall , (smx_host_t) simcall->args[0].dp, (smx_host_t) simcall->args[1].dp);
+       SIMIX_vm_migrate((smx_host_t) simcall->args[0].dp,(smx_host_t) simcall->args[1].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_GET_PM:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_GET_PM:

-      simcall->result.dp = simcall_HANDLER_vm_get_pm(simcall , (smx_host_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_vm_get_pm((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_SET_BOUND:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_SET_BOUND:

-       simcall_HANDLER_vm_set_bound(simcall , (smx_host_t) simcall->args[0].dp,  simcall->args[1].d);
+       SIMIX_vm_set_bound((smx_host_t) simcall->args[0].dp, simcall->args[1].d);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_SET_AFFINITY:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_SET_AFFINITY:

-       simcall_HANDLER_vm_set_affinity(simcall , (smx_host_t) simcall->args[0].dp, (smx_host_t) simcall->args[1].dp,  simcall->args[2].ul);
+       SIMIX_vm_set_affinity((smx_host_t) simcall->args[0].dp,(smx_host_t) simcall->args[1].dp, simcall->args[2].ul);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_DESTROY:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_VM_DESTROY:

-       simcall_HANDLER_vm_destroy(simcall , (smx_host_t) simcall->args[0].dp);
+       SIMIX_vm_destroy((smx_host_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -392,7 +392,7 @@ case SIMCALL_PROCESS_KILLALL:
       break;  
 
 case SIMCALL_PROCESS_CLEANUP:
       break;  
 
 case SIMCALL_PROCESS_CLEANUP:

-       simcall_HANDLER_process_cleanup(simcall , (smx_process_t) simcall->args[0].dp);
+       SIMIX_process_cleanup((smx_process_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -411,47 +411,47 @@ case SIMCALL_PROCESS_RESUME:
       break;  
 
 case SIMCALL_PROCESS_COUNT:
       break;  
 
 case SIMCALL_PROCESS_COUNT:

-      simcall->result.i = simcall_HANDLER_process_count(simcall );
+      simcall->result.i = SIMIX_process_count();

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_GET_PID:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_GET_PID:

-      simcall->result.i = simcall_HANDLER_process_get_PID(simcall , (smx_process_t) simcall->args[0].dp);
+      simcall->result.i = SIMIX_process_get_PID((smx_process_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_GET_PPID:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_GET_PPID:

-      simcall->result.i = simcall_HANDLER_process_get_PPID(simcall , (smx_process_t) simcall->args[0].dp);
+      simcall->result.i = SIMIX_process_get_PPID((smx_process_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_GET_DATA:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_GET_DATA:

-      simcall->result.dp = simcall_HANDLER_process_get_data(simcall , (smx_process_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_process_get_data((smx_process_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_SET_DATA:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_SET_DATA:

-       simcall_HANDLER_process_set_data(simcall , (smx_process_t) simcall->args[0].dp,  simcall->args[1].dp);
+       SIMIX_process_set_data((smx_process_t) simcall->args[0].dp, simcall->args[1].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_GET_HOST:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_GET_HOST:

-      simcall->result.dp = simcall_HANDLER_process_get_host(simcall , (smx_process_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_process_get_host((smx_process_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_GET_NAME:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_GET_NAME:

-      simcall->result.cc = simcall_HANDLER_process_get_name(simcall , (smx_process_t) simcall->args[0].dp);
+      simcall->result.cc = SIMIX_process_get_name((smx_process_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_IS_SUSPENDED:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_IS_SUSPENDED:

-      simcall->result.i = simcall_HANDLER_process_is_suspended(simcall , (smx_process_t) simcall->args[0].dp);
+      simcall->result.i = SIMIX_process_is_suspended((smx_process_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_GET_PROPERTIES:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_GET_PROPERTIES:

-      simcall->result.dp = simcall_HANDLER_process_get_properties(simcall , (smx_process_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_process_get_properties((smx_process_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -464,12 +464,12 @@ case SIMCALL_PROCESS_SLEEP:
        break;  
 
 case SIMCALL_PROCESS_ON_EXIT:
        break;  
 
 case SIMCALL_PROCESS_ON_EXIT:

-       simcall_HANDLER_process_on_exit(simcall , (smx_process_t) simcall->args[0].dp, (int_f_pvoid_pvoid_t) simcall->args[1].fp,  simcall->args[2].dp);
+       SIMIX_process_on_exit((smx_process_t) simcall->args[0].dp,(int_f_pvoid_pvoid_t) simcall->args[1].fp, simcall->args[2].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_AUTO_RESTART_SET:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_PROCESS_AUTO_RESTART_SET:

-       simcall_HANDLER_process_auto_restart_set(simcall , (smx_process_t) simcall->args[0].dp,  simcall->args[1].i);
+       SIMIX_process_auto_restart_set((smx_process_t) simcall->args[0].dp, simcall->args[1].i);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -479,32 +479,32 @@ case SIMCALL_PROCESS_RESTART:
       break;  
 
 case SIMCALL_RDV_CREATE:
       break;  
 
 case SIMCALL_RDV_CREATE:

-      simcall->result.dp = simcall_HANDLER_rdv_create(simcall ,  simcall->args[0].cc);
+      simcall->result.dp = SIMIX_rdv_create( simcall->args[0].cc);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_RDV_DESTROY:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_RDV_DESTROY:

-       simcall_HANDLER_rdv_destroy(simcall , (smx_rdv_t) simcall->args[0].dp);
+       SIMIX_rdv_destroy((smx_rdv_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_RDV_COMM_COUNT_BY_HOST:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_RDV_COMM_COUNT_BY_HOST:

-      simcall->result.ui = simcall_HANDLER_rdv_comm_count_by_host(simcall , (smx_rdv_t) simcall->args[0].dp, (smx_host_t) simcall->args[1].dp);
+      simcall->result.ui = SIMIX_rdv_comm_count_by_host((smx_rdv_t) simcall->args[0].dp,(smx_host_t) simcall->args[1].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_RDV_GET_HEAD:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_RDV_GET_HEAD:

-      simcall->result.dp = simcall_HANDLER_rdv_get_head(simcall , (smx_rdv_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_rdv_get_head((smx_rdv_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_RDV_SET_RECEIVER:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_RDV_SET_RECEIVER:

-       simcall_HANDLER_rdv_set_receiver(simcall , (smx_rdv_t) simcall->args[0].dp, (smx_process_t) simcall->args[1].dp);
+       SIMIX_rdv_set_receiver((smx_rdv_t) simcall->args[0].dp,(smx_process_t) simcall->args[1].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_RDV_GET_RECEIVER:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_RDV_GET_RECEIVER:

-      simcall->result.dp = simcall_HANDLER_rdv_get_receiver(simcall , (smx_rdv_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_rdv_get_receiver((smx_rdv_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -532,7 +532,7 @@ case SIMCALL_COMM_IRECV:
       break;  
 
 case SIMCALL_COMM_CANCEL:
       break;  
 
 case SIMCALL_COMM_CANCEL:

-       simcall_HANDLER_comm_cancel(simcall , (smx_synchro_t) simcall->args[0].dp);
+       SIMIX_comm_cancel((smx_synchro_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -553,32 +553,32 @@ case SIMCALL_COMM_TESTANY:
        break;  
 
 case SIMCALL_COMM_GET_REMAINS:
        break;  
 
 case SIMCALL_COMM_GET_REMAINS:

-      simcall->result.d = simcall_HANDLER_comm_get_remains(simcall , (smx_synchro_t) simcall->args[0].dp);
+      simcall->result.d = SIMIX_comm_get_remains((smx_synchro_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_COMM_GET_STATE:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_COMM_GET_STATE:

-      simcall->result.i = simcall_HANDLER_comm_get_state(simcall , (smx_synchro_t) simcall->args[0].dp);
+      simcall->result.i = SIMIX_comm_get_state((smx_synchro_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_COMM_GET_SRC_DATA:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_COMM_GET_SRC_DATA:

-      simcall->result.dp = simcall_HANDLER_comm_get_src_data(simcall , (smx_synchro_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_comm_get_src_data((smx_synchro_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_COMM_GET_DST_DATA:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_COMM_GET_DST_DATA:

-      simcall->result.dp = simcall_HANDLER_comm_get_dst_data(simcall , (smx_synchro_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_comm_get_dst_data((smx_synchro_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_COMM_GET_SRC_PROC:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_COMM_GET_SRC_PROC:

-      simcall->result.dp = simcall_HANDLER_comm_get_src_proc(simcall , (smx_synchro_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_comm_get_src_proc((smx_synchro_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_COMM_GET_DST_PROC:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_COMM_GET_DST_PROC:

-      simcall->result.dp = simcall_HANDLER_comm_get_dst_proc(simcall , (smx_synchro_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_comm_get_dst_proc((smx_synchro_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -588,7 +588,7 @@ case SIMCALL_MUTEX_INIT:
       break;  
 
 case SIMCALL_MUTEX_DESTROY:
       break;  
 
 case SIMCALL_MUTEX_DESTROY:

-       simcall_HANDLER_mutex_destroy(simcall , (smx_mutex_t) simcall->args[0].dp);
+       SIMIX_mutex_destroy((smx_mutex_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -597,7 +597,7 @@ case SIMCALL_MUTEX_LOCK:
        break;  
 
 case SIMCALL_MUTEX_TRYLOCK:
        break;  
 
 case SIMCALL_MUTEX_TRYLOCK:

-      simcall->result.i = simcall_mutex_trylock((smx_mutex_t) simcall->args[0].dp);
+      simcall->result.i = simcall_HANDLER_mutex_trylock(simcall , (smx_mutex_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -607,17 +607,17 @@ case SIMCALL_MUTEX_UNLOCK:
       break;  
 
 case SIMCALL_COND_INIT:
       break;  
 
 case SIMCALL_COND_INIT:

-      simcall->result.dp = simcall_HANDLER_cond_init(simcall );
+      simcall->result.dp = SIMIX_cond_init();

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_COND_DESTROY:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_COND_DESTROY:

-       simcall_HANDLER_cond_destroy(simcall , (smx_cond_t) simcall->args[0].dp);
+       SIMIX_cond_destroy((smx_cond_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_COND_SIGNAL:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_COND_SIGNAL:

-       simcall_HANDLER_cond_signal(simcall , (smx_cond_t) simcall->args[0].dp);
+       SIMIX_cond_signal((smx_cond_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -630,17 +630,17 @@ case SIMCALL_COND_WAIT_TIMEOUT:
        break;  
 
 case SIMCALL_COND_BROADCAST:
        break;  
 
 case SIMCALL_COND_BROADCAST:

-       simcall_HANDLER_cond_broadcast(simcall , (smx_cond_t) simcall->args[0].dp);
+       SIMIX_cond_broadcast((smx_cond_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_SEM_INIT:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_SEM_INIT:

-      simcall->result.dp = simcall_HANDLER_sem_init(simcall ,  simcall->args[0].ui);
+      simcall->result.dp = SIMIX_sem_init( simcall->args[0].ui);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_SEM_DESTROY:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_SEM_DESTROY:

-       simcall_HANDLER_sem_destroy(simcall , (smx_sem_t) simcall->args[0].dp);
+       SIMIX_sem_destroy((smx_sem_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -684,7 +684,7 @@ case SIMCALL_FILE_CLOSE:
        break;  
 
 case SIMCALL_FILE_UNLINK:
        break;  
 
 case SIMCALL_FILE_UNLINK:

-      simcall->result.i = simcall_HANDLER_file_unlink(simcall , (smx_file_t) simcall->args[0].dp, (smx_host_t) simcall->args[1].dp);
+      simcall->result.i = SIMIX_file_unlink((smx_file_t) simcall->args[0].dp,(smx_host_t) simcall->args[1].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -724,12 +724,12 @@ case SIMCALL_STORAGE_GET_USED_SIZE:
       break;  
 
 case SIMCALL_STORAGE_GET_PROPERTIES:
       break;  
 
 case SIMCALL_STORAGE_GET_PROPERTIES:

-      simcall->result.dp = simcall_HANDLER_storage_get_properties(simcall , (smx_storage_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_storage_get_properties((smx_storage_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_STORAGE_GET_CONTENT:
       SIMIX_simcall_answer(simcall);
       break;  
 
 case SIMCALL_STORAGE_GET_CONTENT:

-      simcall->result.dp = simcall_HANDLER_storage_get_content(simcall , (smx_storage_t) simcall->args[0].dp);
+      simcall->result.dp = SIMIX_storage_get_content((smx_storage_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -740,7 +740,7 @@ case SIMCALL_ASR_GET_PROPERTIES:
 
 #ifdef HAVE_LATENCY_BOUND_TRACKING
 case SIMCALL_COMM_IS_LATENCY_BOUNDED:
 
 #ifdef HAVE_LATENCY_BOUND_TRACKING
 case SIMCALL_COMM_IS_LATENCY_BOUNDED:

-      simcall->result.i = simcall_HANDLER_comm_is_latency_bounded(simcall , (smx_synchro_t) simcall->args[0].dp);
+      simcall->result.i = SIMIX_comm_is_latency_bounded((smx_synchro_t) simcall->args[0].dp);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 


@@ -748,7 +748,7 @@ case SIMCALL_COMM_IS_LATENCY_BOUNDED:
 
 #ifdef HAVE_TRACING
 case SIMCALL_SET_CATEGORY:
 
 #ifdef HAVE_TRACING
 case SIMCALL_SET_CATEGORY:

-       simcall_HANDLER_set_category(simcall , (smx_synchro_t) simcall->args[0].dp,  simcall->args[1].cc);
+       SIMIX_set_category((smx_synchro_t) simcall->args[0].dp, simcall->args[1].cc);

       SIMIX_simcall_answer(simcall);
       break;  
 
       SIMIX_simcall_answer(simcall);
       break;  
 

diff --git a/src/simix/simcalls.in b/src/simix/simcalls.in
index 8a433a0..d3f47c7 100644 (file)
--- a/src/simix/simcalls.in
+++ b/src/simix/simcalls.in
@@ -12,43 +12,44 @@
 
 # Handler? is either "H" if we need to generate a handler or "-" if we should go without handlers
 
 
 # Handler? is either "H" if we need to generate a handler or "-" if we should go without handlers
 

-Func H host_get_by_name (void*, smx_host_t) (name, const char*)
-Func H host_get_name (const char*) (host, void*, smx_host_t)
-Proc H host_on (void) (host, void*, smx_host_t)
+Func - host_get_by_name (void*, smx_host_t) (name, const char*)
+Func - host_get_name (const char*) (host, void*, smx_host_t)
+Proc - host_on (void) (host, void*, smx_host_t)

 Proc H host_off (void) (host, void*, smx_host_t)
 Proc H host_off (void) (host, void*, smx_host_t)

-Func H host_get_properties (void*, xbt_dict_t) (host, void*, smx_host_t)
-Func H host_get_core (int) (host, void*, smx_host_t)
-Func H host_get_process_list (void*, xbt_swag_t) (host, void*, smx_host_t)
-Func H host_get_speed (double) (host, void*, smx_host_t)
-Func H host_get_available_speed (double) (host, void*, smx_host_t)
-Func H host_get_state (int) (host, void*, smx_host_t)
-Func H host_get_current_power_peak (double) (host, void*, smx_host_t)
-Func H host_get_power_peak_at (double) (host, void*, smx_host_t) (pstate_index, int)
-Func H host_get_nb_pstates (int) (host, void*, smx_host_t)
-Proc H host_set_power_peak_at (void) (host, void*, smx_host_t) (pstate_index, int)
-Func H host_get_consumed_energy (double) (host, void*, smx_host_t)
-Func H host_execute (void*, smx_synchro_t) (name, const char*) (host, void*, smx_host_t) (computation_amount, double) (priority, double) (bound, double) (affinity_mask, unsigned long)
-Func H host_parallel_execute (void*, smx_synchro_t) (name, const char*) (host_nb, int) (host_list, void*, smx_host_t*) (computation_amount, void*, double*) (communication_amount, void*, double*) (amount, double) (rate, double)
-Proc H host_execution_destroy (void) (execution, void*, smx_synchro_t)
-Proc H host_execution_cancel (void) (execution, void*, smx_synchro_t)
-Func H host_execution_get_remains (double) (execution, void*, smx_synchro_t)
-Func H host_execution_get_state (int, e_smx_state_t) (execution, void*, smx_synchro_t)
-Proc H host_execution_set_priority (void) (execution, void*, smx_synchro_t) (priority, double)
-Proc H host_execution_set_bound (void) (execution, void*, smx_synchro_t) (bound, double)
-Proc H host_execution_set_affinity (void) (execution, void*, smx_synchro_t) (ws, void*, smx_host_t) (mask, unsigned long)
+Func - host_get_properties (void*, xbt_dict_t) (host, void*, smx_host_t)
+Func - host_get_core (int) (host, void*, smx_host_t)
+Func - host_get_process_list (void*, xbt_swag_t) (host, void*, smx_host_t)
+Func - host_get_speed (double) (host, void*, smx_host_t)
+Func - host_get_available_speed (double) (host, void*, smx_host_t)
+Func - host_get_state (int) (host, void*, smx_host_t)
+Func - host_get_current_power_peak (double) (host, void*, smx_host_t)
+Func - host_get_power_peak_at (double) (host, void*, smx_host_t) (pstate_index, int)
+Func - host_get_nb_pstates (int) (host, void*, smx_host_t)
+Proc - host_set_power_peak_at (void) (host, void*, smx_host_t) (pstate_index, int)
+Func - host_get_consumed_energy (double) (host, void*, smx_host_t)
+
+Func - host_execute (void*, smx_synchro_t) (name, const char*) (host, void*, smx_host_t) (computation_amount, double) (priority, double) (bound, double) (affinity_mask, unsigned long)
+Func - host_parallel_execute (void*, smx_synchro_t) (name, const char*) (host_nb, int) (host_list, void*, smx_host_t*) (computation_amount, void*, double*) (communication_amount, void*, double*) (amount, double) (rate, double)
+Proc - host_execution_destroy (void) (execution, void*, smx_synchro_t)
+Proc - host_execution_cancel (void) (execution, void*, smx_synchro_t)
+Func - host_execution_get_remains (double) (execution, void*, smx_synchro_t)
+Func - host_execution_get_state (int, e_smx_state_t) (execution, void*, smx_synchro_t)
+Proc - host_execution_set_priority (void) (execution, void*, smx_synchro_t) (priority, double)
+Proc - host_execution_set_bound (void) (execution, void*, smx_synchro_t) (bound, double)
+Proc - host_execution_set_affinity (void) (execution, void*, smx_synchro_t) (ws, void*, smx_host_t) (mask, unsigned long)

 Blck H host_execution_wait (int) (execution, void*, smx_synchro_t)
 Blck H host_execution_wait (int) (execution, void*, smx_synchro_t)

-Func H host_get_mounted_storage_list (void*, xbt_dict_t) (host, void*, smx_host_t)
-Func H host_get_attached_storage_list (void*, xbt_dynar_t) (host, void*, smx_host_t)
-Proc H host_get_params (void) (ind_vm, void*, smx_host_t) (params, void*, ws_params_t)
-Proc H host_set_params (void) (ind_vm, void*, smx_host_t) (params, void*, ws_params_t)
-Func H vm_create (void*, smx_host_t) (name, const char*) (ind_pm, void*, smx_host_t)
-Proc H vm_start (void) (ind_vm, void*, smx_host_t)
-Func H vm_get_state (int) (ind_vm, void*, smx_host_t)
-Proc H vm_migrate (void) (ind_vm, void*, smx_host_t) (ind_dst_pm, void*, smx_host_t)
-Func H vm_get_pm (void*) (ind_vm, void*, smx_host_t)
-Proc H vm_set_bound (void) (ind_vm, void*, smx_host_t) (bound, double)
-Proc H vm_set_affinity (void) (ind_vm, void*, smx_host_t) (ind_pm, void*, smx_host_t) (mask, unsigned long)
-Proc H vm_destroy (void) (ind_vm, void*, smx_host_t)
+Func - host_get_mounted_storage_list (void*, xbt_dict_t) (host, void*, smx_host_t)
+Func - host_get_attached_storage_list (void*, xbt_dynar_t) (host, void*, smx_host_t)
+Proc - host_get_params (void) (ind_vm, void*, smx_host_t) (params, void*, ws_params_t)
+Proc - host_set_params (void) (ind_vm, void*, smx_host_t) (params, void*, ws_params_t)
+Func - vm_create (void*, smx_host_t) (name, const char*) (ind_pm, void*, smx_host_t)
+Proc - vm_start (void) (ind_vm, void*, smx_host_t)
+Func - vm_get_state (int) (ind_vm, void*, smx_host_t)
+Proc - vm_migrate (void) (ind_vm, void*, smx_host_t) (ind_dst_pm, void*, smx_host_t)
+Func - vm_get_pm (void*) (ind_vm, void*, smx_host_t)
+Proc - vm_set_bound (void) (ind_vm, void*, smx_host_t) (bound, double)
+Proc - vm_set_affinity (void) (ind_vm, void*, smx_host_t) (ind_pm, void*, smx_host_t) (mask, unsigned long)
+Proc - vm_destroy (void) (ind_vm, void*, smx_host_t)

 Proc H vm_suspend (void) (ind_vm, void*, smx_host_t)
 Proc H vm_resume (void) (ind_vm, void*, smx_host_t)
 Proc H vm_shutdown (void) (ind_vm, void*, smx_host_t)
 Proc H vm_suspend (void) (ind_vm, void*, smx_host_t)
 Proc H vm_resume (void) (ind_vm, void*, smx_host_t)
 Proc H vm_shutdown (void) (ind_vm, void*, smx_host_t)


@@ -57,59 +58,60 @@ Proc H vm_restore (void) (ind_vm, void*, smx_host_t)
 Proc H process_create (void) (process, void*, smx_process_t*) (name, const char*) (code, FPtr, xbt_main_func_t) (data, void*) (hostname, const char*) (kill_time, double) (argc, int) (argv, void*, char**) (properties, void*, xbt_dict_t) (auto_restart, int)
 Proc H process_kill (void) (process, void*, smx_process_t)
 Proc H process_killall (void) (reset_pid, int)
 Proc H process_create (void) (process, void*, smx_process_t*) (name, const char*) (code, FPtr, xbt_main_func_t) (data, void*) (hostname, const char*) (kill_time, double) (argc, int) (argv, void*, char**) (properties, void*, xbt_dict_t) (auto_restart, int)
 Proc H process_kill (void) (process, void*, smx_process_t)
 Proc H process_killall (void) (reset_pid, int)

-Proc H process_cleanup (void) (process, void*, smx_process_t)
+Proc - process_cleanup (void) (process, void*, smx_process_t)

 Proc H process_change_host (void) (process, void*, smx_process_t) (dest, void*, smx_host_t)
 Blck H process_suspend (void) (process, void*, smx_process_t)
 Proc H process_resume (void) (process, void*, smx_process_t)
 Proc H process_change_host (void) (process, void*, smx_process_t) (dest, void*, smx_host_t)
 Blck H process_suspend (void) (process, void*, smx_process_t)
 Proc H process_resume (void) (process, void*, smx_process_t)

-Func H process_count (int)
-Func H process_get_PID (int) (process, void*, smx_process_t)
-Func H process_get_PPID (int) (process, void*, smx_process_t)
-Func H process_get_data (void*) (process, void*, smx_process_t)
-Proc H process_set_data (void) (process, void*, smx_process_t) (data, void*)
-Func H process_get_host (void*, smx_host_t) (process, void*, smx_process_t)
-Func H process_get_name (const char*) (process, void*, smx_process_t)
-Func H process_is_suspended (int) (process, void*, smx_process_t)
-Func H process_get_properties (void*, xbt_dict_t) (process, void*, smx_process_t)
+Func - process_count (int)
+Func - process_get_PID (int) (process, void*, smx_process_t)
+Func - process_get_PPID (int) (process, void*, smx_process_t)
+Func - process_get_data (void*) (process, void*, smx_process_t)
+Proc - process_set_data (void) (process, void*, smx_process_t) (data, void*)
+Func - process_get_host (void*, smx_host_t) (process, void*, smx_process_t)
+Func - process_get_name (const char*) (process, void*, smx_process_t)
+Func - process_is_suspended (int) (process, void*, smx_process_t)
+Func - process_get_properties (void*, xbt_dict_t) (process, void*, smx_process_t)

 Blck H process_join (int) (process, void*, smx_process_t) (timeout, double)
 Blck H process_sleep (int) (duration, double)
 Blck H process_join (int) (process, void*, smx_process_t) (timeout, double)
 Blck H process_sleep (int) (duration, double)

-Proc H process_on_exit (void) (process, void*, smx_process_t) (fun, FPtr, int_f_pvoid_pvoid_t) (data, void*)
-Proc H process_auto_restart_set (void) (process, void*, smx_process_t) (auto_restart, int)
+Proc - process_on_exit (void) (process, void*, smx_process_t) (fun, FPtr, int_f_pvoid_pvoid_t) (data, void*)
+Proc - process_auto_restart_set (void) (process, void*, smx_process_t) (auto_restart, int)

 Func H process_restart (void*, smx_process_t) (process, void*, smx_process_t)
 Func H process_restart (void*, smx_process_t) (process, void*, smx_process_t)

-Func H rdv_create (void*, smx_rdv_t) (name, const char*)
-Proc H rdv_destroy (void) (rdv, void*, smx_rdv_t)
-Func H rdv_comm_count_by_host (unsigned int) (rdv, void*, smx_rdv_t) (host, void*, smx_host_t)
-Func H rdv_get_head (void*, smx_synchro_t) (rdv, void*, smx_rdv_t)
-Proc H rdv_set_receiver (void) (rdv, void*, smx_rdv_t) (receiver, void*, smx_process_t)
-Func H rdv_get_receiver (void*, smx_process_t) (rdv, void*, smx_rdv_t)
+
+Func - rdv_create (void*, smx_rdv_t) (name, const char*)
+Proc - rdv_destroy (void) (rdv, void*, smx_rdv_t)
+Func - rdv_comm_count_by_host (unsigned int) (rdv, void*, smx_rdv_t) (host, void*, smx_host_t)
+Func - rdv_get_head (void*, smx_synchro_t) (rdv, void*, smx_rdv_t)
+Proc - rdv_set_receiver (void) (rdv, void*, smx_rdv_t) (receiver, void*, smx_process_t)
+Func - rdv_get_receiver (void*, smx_process_t) (rdv, void*, smx_rdv_t)

 Func H comm_iprobe (void*, smx_synchro_t) (rdv, void*, smx_rdv_t) (type, int) (src, int) (tag, int) (match_fun, FPtr, simix_match_func_t) (data, void*)
 Blck H comm_send (void) (src, void*, smx_process_t) (rdv, void*, smx_rdv_t)  (task_size, double) (rate, double) (src_buff, void*) (src_buff_size, size_t) (match_fun, FPtr, simix_match_func_t) (copy_data_fun, FPtr, simix_copy_data_func_t) (data, void*) (timeout, double)
 Func H comm_isend (void*, smx_synchro_t) (src, void*, smx_process_t) (rdv, void*, smx_rdv_t) (task_size, double) (rate, double) (src_buff, void*) (src_buff_size, size_t) (match_fun, FPtr, simix_match_func_t) (clean_fun, FPtr, simix_clean_func_t) (copy_data_fun, FPtr, simix_copy_data_func_t) (data, void*) (detached, int)
 Blck H comm_recv (void) (rdv, void*, smx_rdv_t) (dst_buff, void*) (dst_buff_size, void*, size_t*) (match_fun, FPtr, simix_match_func_t) (copy_data_fun, FPtr, simix_copy_data_func_t) (data, void*) (timeout, double) (rate, double)
 Func H comm_irecv (void*, smx_synchro_t) (rdv, void*, smx_rdv_t) (dst_buff, void*) (dst_buff_size, void*, size_t*) (match_fun, FPtr, simix_match_func_t) (copy_data_fun, FPtr, simix_copy_data_func_t) (data, void*) (rate, double)
 Func H comm_iprobe (void*, smx_synchro_t) (rdv, void*, smx_rdv_t) (type, int) (src, int) (tag, int) (match_fun, FPtr, simix_match_func_t) (data, void*)
 Blck H comm_send (void) (src, void*, smx_process_t) (rdv, void*, smx_rdv_t)  (task_size, double) (rate, double) (src_buff, void*) (src_buff_size, size_t) (match_fun, FPtr, simix_match_func_t) (copy_data_fun, FPtr, simix_copy_data_func_t) (data, void*) (timeout, double)
 Func H comm_isend (void*, smx_synchro_t) (src, void*, smx_process_t) (rdv, void*, smx_rdv_t) (task_size, double) (rate, double) (src_buff, void*) (src_buff_size, size_t) (match_fun, FPtr, simix_match_func_t) (clean_fun, FPtr, simix_clean_func_t) (copy_data_fun, FPtr, simix_copy_data_func_t) (data, void*) (detached, int)
 Blck H comm_recv (void) (rdv, void*, smx_rdv_t) (dst_buff, void*) (dst_buff_size, void*, size_t*) (match_fun, FPtr, simix_match_func_t) (copy_data_fun, FPtr, simix_copy_data_func_t) (data, void*) (timeout, double) (rate, double)
 Func H comm_irecv (void*, smx_synchro_t) (rdv, void*, smx_rdv_t) (dst_buff, void*) (dst_buff_size, void*, size_t*) (match_fun, FPtr, simix_match_func_t) (copy_data_fun, FPtr, simix_copy_data_func_t) (data, void*) (rate, double)

-Proc H comm_cancel (void) (comm, void*, smx_synchro_t)
+Proc - comm_cancel (void) (comm, void*, smx_synchro_t)

 Blck H comm_waitany (int) (comms, void*, xbt_dynar_t)
 Blck H comm_wait (void) (comm, void*, smx_synchro_t) (timeout, double)
 Blck H comm_test (int) (comm, void*, smx_synchro_t)
 Blck H comm_testany (int) (comms, void*, xbt_dynar_t)
 Blck H comm_waitany (int) (comms, void*, xbt_dynar_t)
 Blck H comm_wait (void) (comm, void*, smx_synchro_t) (timeout, double)
 Blck H comm_test (int) (comm, void*, smx_synchro_t)
 Blck H comm_testany (int) (comms, void*, xbt_dynar_t)

-Func H comm_get_remains (double) (comm, void*, smx_synchro_t)
-Func H comm_get_state (int, e_smx_state_t) (comm, void*, smx_synchro_t)
-Func H comm_get_src_data (void*) (comm, void*, smx_synchro_t)
-Func H comm_get_dst_data (void*) (comm, void*, smx_synchro_t)
-Func H comm_get_src_proc (void*, smx_process_t) (comm, void*, smx_synchro_t)
-Func H comm_get_dst_proc (void*, smx_process_t) (comm, void*, smx_synchro_t)
+Func - comm_get_remains (double) (comm, void*, smx_synchro_t)
+Func - comm_get_state (int, e_smx_state_t) (comm, void*, smx_synchro_t)
+Func - comm_get_src_data (void*) (comm, void*, smx_synchro_t)
+Func - comm_get_dst_data (void*) (comm, void*, smx_synchro_t)
+Func - comm_get_src_proc (void*, smx_process_t) (comm, void*, smx_synchro_t)
+Func - comm_get_dst_proc (void*, smx_process_t) (comm, void*, smx_synchro_t)

 Func H mutex_init (void*, smx_mutex_t)
 Func H mutex_init (void*, smx_mutex_t)

-Proc H mutex_destroy (void) (mutex, void*, smx_mutex_t)
+Proc - mutex_destroy (void) (mutex, void*, smx_mutex_t)

 Blck H mutex_lock (void) (mutex, void*, smx_mutex_t)
 Blck H mutex_lock (void) (mutex, void*, smx_mutex_t)

-Func - mutex_trylock (int) (mutex, void*, smx_mutex_t)
+Func H mutex_trylock (int) (mutex, void*, smx_mutex_t)

 Proc H mutex_unlock (void) (mutex, void*, smx_mutex_t)
 Proc H mutex_unlock (void) (mutex, void*, smx_mutex_t)

-Func H cond_init (void*, smx_cond_t)
-Proc H cond_destroy (void) (cond, void*, smx_cond_t)
-Proc H cond_signal (void) (cond, void*, smx_cond_t)
+Func - cond_init (void*, smx_cond_t)
+Proc - cond_destroy (void) (cond, void*, smx_cond_t)
+Proc - cond_signal (void) (cond, void*, smx_cond_t)

 Blck H cond_wait (void) (cond, void*, smx_cond_t) (mutex, void*, smx_mutex_t)
 Blck H cond_wait_timeout (void) (cond, void*, smx_cond_t) (mutex, void*, smx_mutex_t) (timeout, double)
 Blck H cond_wait (void) (cond, void*, smx_cond_t) (mutex, void*, smx_mutex_t)
 Blck H cond_wait_timeout (void) (cond, void*, smx_cond_t) (mutex, void*, smx_mutex_t) (timeout, double)

-Proc H cond_broadcast (void) (cond, void*, smx_cond_t)
-Func H sem_init (void*, smx_sem_t) (capacity, unsigned int)
-Proc H sem_destroy (void) (sem, void*, smx_sem_t)
+Proc - cond_broadcast (void) (cond, void*, smx_cond_t)
+Func - sem_init (void*, smx_sem_t) (capacity, unsigned int)
+Proc - sem_destroy (void) (sem, void*, smx_sem_t)

 Proc H sem_release (void) (sem, void*, smx_sem_t)
 Func H sem_would_block (int) (sem, void*, smx_sem_t)
 Blck H sem_acquire (void) (sem, void*, smx_sem_t)
 Proc H sem_release (void) (sem, void*, smx_sem_t)
 Func H sem_would_block (int) (sem, void*, smx_sem_t)
 Blck H sem_acquire (void) (sem, void*, smx_sem_t)


@@ -119,7 +121,7 @@ Blck H file_read (sg_size_t) (fd, void*, smx_file_t) (size, sg_size_t) (host, vo
 Blck H file_write (sg_size_t) (fd, void*, smx_file_t) (size, sg_size_t) (host, void*, smx_host_t)
 Blck H file_open (void*, smx_file_t) (fullpath, const char*) (host, void*, smx_host_t)
 Blck H file_close (int) (fd, void*, smx_file_t) (host, void*, smx_host_t)
 Blck H file_write (sg_size_t) (fd, void*, smx_file_t) (size, sg_size_t) (host, void*, smx_host_t)
 Blck H file_open (void*, smx_file_t) (fullpath, const char*) (host, void*, smx_host_t)
 Blck H file_close (int) (fd, void*, smx_file_t) (host, void*, smx_host_t)

-Func H file_unlink (int) (fd, void*, smx_file_t) (host, void*, smx_host_t)
+Func - file_unlink (int) (fd, void*, smx_file_t) (host, void*, smx_host_t)

 Func H file_get_size (sg_size_t) (fd, void*, smx_file_t)
 Func H file_tell (sg_size_t) (fd, void*, smx_file_t)
 Func H file_seek (int) (fd, void*, smx_file_t) (offset, sg_offset_t) (origin, int)
 Func H file_get_size (sg_size_t) (fd, void*, smx_file_t)
 Func H file_tell (sg_size_t) (fd, void*, smx_file_t)
 Func H file_seek (int) (fd, void*, smx_file_t) (offset, sg_offset_t) (origin, int)


@@ -127,13 +129,13 @@ Func H file_get_info (void*, xbt_dynar_t) (fd, void*, smx_file_t)
 Func H file_move (int) (fd, void*, smx_file_t) (fullpath, const char*)
 Func H storage_get_free_size (sg_size_t) (storage, void*, smx_storage_t)
 Func H storage_get_used_size (sg_size_t) (name, void*, smx_storage_t)
 Func H file_move (int) (fd, void*, smx_file_t) (fullpath, const char*)
 Func H storage_get_free_size (sg_size_t) (storage, void*, smx_storage_t)
 Func H storage_get_used_size (sg_size_t) (name, void*, smx_storage_t)

-Func H storage_get_properties (void*, xbt_dict_t) (storage, void*, smx_storage_t)
-Func H storage_get_content (void*, xbt_dict_t) (storage, void*, smx_storage_t)
+Func - storage_get_properties (void*, xbt_dict_t) (storage, void*, smx_storage_t)
+Func - storage_get_content (void*, xbt_dict_t) (storage, void*, smx_storage_t)

 Func H asr_get_properties (void*, xbt_dict_t) (name, const char*)
 ## HAVE_LATENCY_BOUND_TRACKING
 Func H asr_get_properties (void*, xbt_dict_t) (name, const char*)
 ## HAVE_LATENCY_BOUND_TRACKING

-Func H comm_is_latency_bounded (int) (comm, void*, smx_synchro_t)
+Func - comm_is_latency_bounded (int) (comm, void*, smx_synchro_t)

 ## HAVE_TRACING
 ## HAVE_TRACING

-Proc H set_category (void) (synchro, void*, smx_synchro_t) (category, const char*)
+Proc - set_category (void) (synchro, void*, smx_synchro_t) (category, const char*)

 ## HAVE_MC
 Func H mc_snapshot (void*, mc_snapshot_t)
 Func H mc_compare_snapshots (int) (s1, void*, mc_snapshot_t) (s2, void*, mc_snapshot_t)
 ## HAVE_MC
 Func H mc_snapshot (void*, mc_snapshot_t)
 Func H mc_compare_snapshots (int) (s1, void*, mc_snapshot_t) (s2, void*, mc_snapshot_t)

diff --git a/src/simix/simcalls.py b/src/simix/simcalls.py
index a4eaa32..99a968a 100755 (executable)
--- a/src/simix/simcalls.py
+++ b/src/simix/simcalls.py
@@ -132,7 +132,7 @@ class Simcall(object):
                                                                 ''.join(', %s simcall->args[%d].%s'%(arg.cast(), i, arg.field()) 
                                                                         for i, arg in enumerate(self.args))))
       else:
                                                                 ''.join(', %s simcall->args[%d].%s'%(arg.cast(), i, arg.field()) 
                                                                         for i, arg in enumerate(self.args))))
       else:

-          res.append('      %ssimcall_%s(%s);'%('simcall->result.%s = '%self.res.field() if self.call_kind == 'Func' else ' ',
+          res.append('      %sSIMIX_%s(%s);'%('simcall->result.%s = '%self.res.field() if self.call_kind == 'Func' else ' ',

                                                 self.name,  
                                                 ','.join('%s simcall->args[%d].%s'%(arg.cast(), i, arg.field()) 
                                                          for i, arg in enumerate(self.args))))
                                                 self.name,  
                                                 ','.join('%s simcall->args[%d].%s'%(arg.cast(), i, arg.field()) 
                                                          for i, arg in enumerate(self.args))))


@@ -151,7 +151,7 @@ class Simcall(object):
           res.append('    if (0) simcall_HANDLER_%s(%s);'%(self.name,
                                                            ', '.join(["&self->simcall"]+ [arg.name for arg in self.args])))
       else:
           res.append('    if (0) simcall_HANDLER_%s(%s);'%(self.name,
                                                            ', '.join(["&self->simcall"]+ [arg.name for arg in self.args])))
       else:

-          res.append('    if (0) simcall_%s(%s);'%(self.name,
+          res.append('    if (0) SIMIX_%s(%s);'%(self.name,

                                                    ', '.join(arg.name for arg in self.args)))
       res.append('    /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */')
       res.append('')
                                                    ', '.join(arg.name for arg in self.args)))
       res.append('    /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */')
       res.append('')


@@ -227,7 +227,9 @@ def header(name):
     return fd
 
 def handle(fd,func, simcalls, guarded_simcalls):
     return fd
 
 def handle(fd,func, simcalls, guarded_simcalls):

-    fd.write('\n'.join(func(simcall) for simcall in simcalls))
+    def nonempty(e): return e != ''
+    fd.write('\n'.join( filter(nonempty, (func(simcall) for simcall in simcalls))))
+    

     for guard, list in guarded_simcalls.items():
         fd.write('\n#ifdef %s\n'%(guard))
         fd.write('\n'.join(func(simcall) for simcall in list))
     for guard, list in guarded_simcalls.items():
         fd.write('\n#ifdef %s\n'%(guard))
         fd.write('\n'.join(func(simcall) for simcall in list))

diff --git a/src/simix/smx_host.c b/src/simix/smx_host.c
index 01cff53..30043b0 100644 (file)
--- a/src/simix/smx_host.c
+++ b/src/simix/smx_host.c
@@ -37,11 +37,6 @@ smx_host_t SIMIX_host_create(const char *name,
   return xbt_lib_get_elm_or_null(host_lib, name);
 }
 
   return xbt_lib_get_elm_or_null(host_lib, name);
 }
 

-void simcall_HANDLER_host_on(smx_simcall_t simcall, smx_host_t h)
-{
-  SIMIX_host_on(h);
-}
-

 /**
  * \brief Start the host if it is off
  *
 /**
  * \brief Start the host if it is off
  *


@@ -95,7 +90,7 @@ void SIMIX_host_on(smx_host_t h)
 
 void simcall_HANDLER_host_off(smx_simcall_t simcall, smx_host_t h)
 {
 
 void simcall_HANDLER_host_off(smx_simcall_t simcall, smx_host_t h)
 {

-  SIMIX_host_off(h, simcall->issuer);
+ SIMIX_host_off(h, simcall->issuer);

 }
 
 /**
 }
 
 /**


@@ -116,18 +111,10 @@ void SIMIX_host_off(smx_host_t h, smx_process_t issuer)
       smx_process_t process = NULL;
       xbt_swag_foreach(process, host->process_list) {
         SIMIX_process_kill(process, issuer);
       smx_process_t process = NULL;
       xbt_swag_foreach(process, host->process_list) {
         SIMIX_process_kill(process, issuer);

-       XBT_DEBUG("Killing %s on %s by %s", process->name,  sg_host_name(process->smx_host), issuer->name);
+        XBT_DEBUG("Killing %s on %s by %s", process->name,  sg_host_name(process->smx_host), issuer->name);

       }
     }
   }
       }
     }
   }

-  /*xbt_dynar_t vms = surf_workstation_get_vms(h);
-  unsigned int cpt;
-  smx_host_t vm;
-  xbt_dynar_foreach(vms, cpt, vm) {
-    SIMIX_vm_shutdown(vm, issuer);
-    SIMIX_vm_destroy(vm);
-  }
-  xbt_dynar_free(&vms);*/

 }
 
 /**
 }
 
 /**


@@ -164,9 +151,6 @@ void SIMIX_host_destroy(void *h)
   return;
 }
 
   return;
 }
 

-smx_host_t simcall_HANDLER_host_get_by_name(smx_simcall_t simcall, const char *name){
-   return SIMIX_host_get_by_name(name);
-}

 smx_host_t SIMIX_host_get_by_name(const char *name){
   xbt_assert(((simix_global != NULL)
                && (host_lib != NULL)),
 smx_host_t SIMIX_host_get_by_name(const char *name){
   xbt_assert(((simix_global != NULL)
                && (host_lib != NULL)),


@@ -192,45 +176,29 @@ const char* SIMIX_host_self_get_name(void)
   return SIMIX_host_get_name(host);
 }
 
   return SIMIX_host_get_name(host);
 }
 

-const char* simcall_HANDLER_host_get_name(smx_simcall_t simcall, smx_host_t host){
-   return SIMIX_host_get_name(host);
-}

 const char* SIMIX_host_get_name(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters");
 
   return sg_host_name(host);
 }
 
 const char* SIMIX_host_get_name(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters");
 
   return sg_host_name(host);
 }
 

-xbt_dict_t simcall_HANDLER_host_get_properties(smx_simcall_t simcall, smx_host_t host){
-  return SIMIX_host_get_properties(host);
-}

 xbt_dict_t SIMIX_host_get_properties(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 
   return surf_resource_get_properties(surf_workstation_resource_priv(host));
 }
 
 xbt_dict_t SIMIX_host_get_properties(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 
   return surf_resource_get_properties(surf_workstation_resource_priv(host));
 }
 

-double simcall_HANDLER_host_get_speed(smx_simcall_t simcall, smx_host_t host){
-  return SIMIX_host_get_speed(host);
-}

 double SIMIX_host_get_speed(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
   return surf_workstation_get_speed(host, 1.0);
 }
 
 double SIMIX_host_get_speed(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
   return surf_workstation_get_speed(host, 1.0);
 }
 

-int simcall_HANDLER_host_get_core(smx_simcall_t simcall, smx_host_t host){
-  return SIMIX_host_get_core(host);
-}

 int SIMIX_host_get_core(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 
   return surf_workstation_get_core(host);
 }
 
 int SIMIX_host_get_core(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 
   return surf_workstation_get_core(host);
 }
 

-xbt_swag_t simcall_HANDLER_host_get_process_list(smx_simcall_t simcall, smx_host_t host){
-  return SIMIX_host_get_process_list(host);
-}
-

 xbt_swag_t SIMIX_host_get_process_list(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
   smx_host_priv_t host_priv = SIMIX_host_priv(host);
 xbt_swag_t SIMIX_host_get_process_list(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
   smx_host_priv_t host_priv = SIMIX_host_priv(host);


@@ -239,35 +207,23 @@ xbt_swag_t SIMIX_host_get_process_list(smx_host_t host){
 }
 
 
 }
 
 

-double simcall_HANDLER_host_get_available_speed(smx_simcall_t simcall, smx_host_t host){
-  return SIMIX_host_get_available_speed(host);
-}

 double SIMIX_host_get_available_speed(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 
   return surf_workstation_get_available_speed(host);
 }
 
 double SIMIX_host_get_available_speed(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 
   return surf_workstation_get_available_speed(host);
 }
 

-double simcall_HANDLER_host_get_current_power_peak(smx_simcall_t simcall, smx_host_t host){
-  return SIMIX_host_get_current_power_peak(host);
-}

 double SIMIX_host_get_current_power_peak(smx_host_t host) {
          xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
          return surf_workstation_get_current_power_peak(host);
 }
 
 double SIMIX_host_get_current_power_peak(smx_host_t host) {
          xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
          return surf_workstation_get_current_power_peak(host);
 }
 

-double simcall_HANDLER_host_get_power_peak_at(smx_simcall_t simcall, smx_host_t host, int pstate_index){
-  return SIMIX_host_get_power_peak_at(host, pstate_index);
-}

 double SIMIX_host_get_power_peak_at(smx_host_t host, int pstate_index) {
          xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 
          return surf_workstation_get_power_peak_at(host, pstate_index);
 }
 
 double SIMIX_host_get_power_peak_at(smx_host_t host, int pstate_index) {
          xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 
          return surf_workstation_get_power_peak_at(host, pstate_index);
 }
 

-int simcall_HANDLER_host_get_nb_pstates(smx_simcall_t simcall, smx_host_t host){
-  return SIMIX_host_get_nb_pstates(host);
-}

 int SIMIX_host_get_nb_pstates(smx_host_t host) {
          xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 
 int SIMIX_host_get_nb_pstates(smx_host_t host) {
          xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 


@@ -275,26 +231,17 @@ int SIMIX_host_get_nb_pstates(smx_host_t host) {
 }
 
 
 }
 
 

-void simcall_HANDLER_host_set_power_peak_at(smx_simcall_t simcall, smx_host_t host, int pstate_index){
-  SIMIX_host_set_power_peak_at(host, pstate_index);
-}

 void SIMIX_host_set_power_peak_at(smx_host_t host, int pstate_index) {
          xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 
          surf_workstation_set_power_peak_at(host, pstate_index);
 }
 
 void SIMIX_host_set_power_peak_at(smx_host_t host, int pstate_index) {
          xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 
          surf_workstation_set_power_peak_at(host, pstate_index);
 }
 

-double simcall_HANDLER_host_get_consumed_energy(smx_simcall_t simcall, smx_host_t host){
-  return SIMIX_host_get_consumed_energy(host);
-}

 double SIMIX_host_get_consumed_energy(smx_host_t host) {
          xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
          return surf_workstation_get_consumed_energy(host);
 }
 
 double SIMIX_host_get_consumed_energy(smx_host_t host) {
          xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
          return surf_workstation_get_consumed_energy(host);
 }
 

-int simcall_HANDLER_host_get_state(smx_simcall_t simcall, smx_host_t host){
-  return SIMIX_host_get_state(host);
-}

 int SIMIX_host_get_state(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 
 int SIMIX_host_get_state(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 


@@ -415,10 +362,6 @@ void SIMIX_host_autorestart(smx_host_t host)
     xbt_die("No function for simix_global->autorestart");
 }
 
     xbt_die("No function for simix_global->autorestart");
 }
 

-smx_synchro_t simcall_HANDLER_host_execute(smx_simcall_t simcall,const char *name,
-    smx_host_t host, double computation_amount, double priority, double bound, unsigned long affinity_mask){
-  return SIMIX_host_execute(name, host, computation_amount, priority, bound, affinity_mask);
-}

 smx_synchro_t SIMIX_host_execute(const char *name,
     smx_host_t host, double computation_amount, double priority, double bound, unsigned long affinity_mask){
 
 smx_synchro_t SIMIX_host_execute(const char *name,
     smx_host_t host, double computation_amount, double priority, double bound, unsigned long affinity_mask){
 


@@ -460,13 +403,6 @@ smx_synchro_t SIMIX_host_execute(const char *name,
   return synchro;
 }
 
   return synchro;
 }
 

-smx_synchro_t simcall_HANDLER_host_parallel_execute(smx_simcall_t simcall, const char *name,
-    int host_nb, smx_host_t *host_list,
-    double *computation_amount, double *communication_amount,
-    double amount, double rate){
-  return SIMIX_host_parallel_execute(name, host_nb, host_list, computation_amount,
-                                    communication_amount, amount, rate);
-}

 smx_synchro_t SIMIX_host_parallel_execute(const char *name,
     int host_nb, smx_host_t *host_list,
     double *computation_amount, double *communication_amount,
 smx_synchro_t SIMIX_host_parallel_execute(const char *name,
     int host_nb, smx_host_t *host_list,
     double *computation_amount, double *communication_amount,


@@ -517,9 +453,6 @@ smx_synchro_t SIMIX_host_parallel_execute(const char *name,
   return synchro;
 }
 
   return synchro;
 }
 

-void simcall_HANDLER_host_execution_destroy(smx_simcall_t simcall, smx_synchro_t synchro){
-  SIMIX_host_execution_destroy(synchro);
-}

 void SIMIX_host_execution_destroy(smx_synchro_t synchro){
   XBT_DEBUG("Destroy synchro %p", synchro);
 
 void SIMIX_host_execution_destroy(smx_synchro_t synchro){
   XBT_DEBUG("Destroy synchro %p", synchro);
 


@@ -531,9 +464,6 @@ void SIMIX_host_execution_destroy(smx_synchro_t synchro){
   xbt_mallocator_release(simix_global->synchro_mallocator, synchro);
 }
 
   xbt_mallocator_release(simix_global->synchro_mallocator, synchro);
 }
 

-void simcall_HANDLER_host_execution_cancel(smx_simcall_t simcall, smx_synchro_t synchro){
-  SIMIX_host_execution_cancel(synchro);
-}

 void SIMIX_host_execution_cancel(smx_synchro_t synchro){
   XBT_DEBUG("Cancel synchro %p", synchro);
 
 void SIMIX_host_execution_cancel(smx_synchro_t synchro){
   XBT_DEBUG("Cancel synchro %p", synchro);
 


@@ -541,9 +471,6 @@ void SIMIX_host_execution_cancel(smx_synchro_t synchro){
     surf_action_cancel(synchro->execution.surf_exec);
 }
 
     surf_action_cancel(synchro->execution.surf_exec);
 }
 

-double simcall_HANDLER_host_execution_get_remains(smx_simcall_t simcall, smx_synchro_t synchro){
-  return SIMIX_host_execution_get_remains(synchro);
-}

 double SIMIX_host_execution_get_remains(smx_synchro_t synchro){
   double result = 0.0;
 
 double SIMIX_host_execution_get_remains(smx_synchro_t synchro){
   double result = 0.0;
 


@@ -553,37 +480,22 @@ double SIMIX_host_execution_get_remains(smx_synchro_t synchro){
   return result;
 }
 
   return result;
 }
 

-e_smx_state_t simcall_HANDLER_host_execution_get_state(smx_simcall_t simcall, smx_synchro_t synchro){
-  return SIMIX_host_execution_get_state(synchro);
-}

 e_smx_state_t SIMIX_host_execution_get_state(smx_synchro_t synchro){
   return synchro->state;
 }
 
 e_smx_state_t SIMIX_host_execution_get_state(smx_synchro_t synchro){
   return synchro->state;
 }
 

-void simcall_HANDLER_host_execution_set_priority(smx_simcall_t simcall, smx_synchro_t synchro,
-                                       double priority){
-  SIMIX_host_execution_set_priority(synchro, priority);
-}

 void SIMIX_host_execution_set_priority(smx_synchro_t synchro, double priority){
 
   if(synchro->execution.surf_exec)
        surf_action_set_priority(synchro->execution.surf_exec, priority);
 }
 
 void SIMIX_host_execution_set_priority(smx_synchro_t synchro, double priority){
 
   if(synchro->execution.surf_exec)
        surf_action_set_priority(synchro->execution.surf_exec, priority);
 }
 

-void simcall_HANDLER_host_execution_set_bound(smx_simcall_t simcall, smx_synchro_t synchro,
-                                       double bound){
-  SIMIX_host_execution_set_bound(synchro, bound);
-}

 void SIMIX_host_execution_set_bound(smx_synchro_t synchro, double bound){
 
   if(synchro->execution.surf_exec)
        surf_cpu_action_set_bound(synchro->execution.surf_exec, bound);
 }
 
 void SIMIX_host_execution_set_bound(smx_synchro_t synchro, double bound){
 
   if(synchro->execution.surf_exec)
        surf_cpu_action_set_bound(synchro->execution.surf_exec, bound);
 }
 

-void simcall_HANDLER_host_execution_set_affinity(smx_simcall_t simcall,
-    smx_synchro_t synchro, smx_host_t host, unsigned long mask){
-  SIMIX_host_execution_set_affinity(synchro, host, mask);
-}

 void SIMIX_host_execution_set_affinity(smx_synchro_t synchro, smx_host_t host, unsigned long mask){
   xbt_assert(synchro->type == SIMIX_SYNC_EXECUTE);
 
 void SIMIX_host_execution_set_affinity(smx_synchro_t synchro, smx_host_t host, unsigned long mask){
   xbt_assert(synchro->type == SIMIX_SYNC_EXECUTE);
 


@@ -699,10 +611,6 @@ void SIMIX_post_host_execute(smx_synchro_t synchro)
 
 
 #ifdef HAVE_TRACING
 
 
 #ifdef HAVE_TRACING

-void simcall_HANDLER_set_category(smx_simcall_t simcall, smx_synchro_t synchro,
-                           const char *category){
-  SIMIX_set_category(synchro, category);
-}

 void SIMIX_set_category(smx_synchro_t synchro, const char *category)
 {
   if (synchro->state != SIMIX_RUNNING) return;
 void SIMIX_set_category(smx_synchro_t synchro, const char *category)
 {
   if (synchro->state != SIMIX_RUNNING) return;


@@ -726,36 +634,18 @@ void SIMIX_host_get_params(smx_host_t ind_vm, ws_params_t params)
   surf_workstation_get_params(ind_vm, params);
 }
 
   surf_workstation_get_params(ind_vm, params);
 }
 

-void simcall_HANDLER_host_get_params(smx_simcall_t simcall, smx_host_t ind_vm, ws_params_t params)
-{
-  SIMIX_host_get_params(ind_vm, params);
-}
-

 void SIMIX_host_set_params(smx_host_t ind_vm, ws_params_t params)
 {
   /* jump to ws_set_params(). */
   surf_workstation_set_params(ind_vm, params);
 }
 
 void SIMIX_host_set_params(smx_host_t ind_vm, ws_params_t params)
 {
   /* jump to ws_set_params(). */
   surf_workstation_set_params(ind_vm, params);
 }
 

-void simcall_HANDLER_host_set_params(smx_simcall_t simcall, smx_host_t ind_vm, ws_params_t params)
-{
-  SIMIX_host_set_params(ind_vm, params);
-}
-
-xbt_dict_t simcall_HANDLER_host_get_mounted_storage_list(smx_simcall_t simcall, smx_host_t host){
-  return SIMIX_host_get_mounted_storage_list(host);
-}
-

 xbt_dict_t SIMIX_host_get_mounted_storage_list(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 
   return surf_workstation_get_mounted_storage_list(host);
 }
 
 xbt_dict_t SIMIX_host_get_mounted_storage_list(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 
   return surf_workstation_get_mounted_storage_list(host);
 }
 

-xbt_dynar_t simcall_HANDLER_host_get_attached_storage_list(smx_simcall_t simcall, smx_host_t host){
-  return SIMIX_host_get_attached_storage_list(host);
-}
-

 xbt_dynar_t SIMIX_host_get_attached_storage_list(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 
 xbt_dynar_t SIMIX_host_get_attached_storage_list(smx_host_t host){
   xbt_assert((host != NULL), "Invalid parameters (simix host is NULL)");
 

diff --git a/src/simix/smx_io.c b/src/simix/smx_io.c
index 365c90b..be6a653 100644 (file)
--- a/src/simix/smx_io.c
+++ b/src/simix/smx_io.c
@@ -52,12 +52,12 @@ void SIMIX_storage_destroy(void *s)
 //SIMIX FILE READ
 void simcall_HANDLER_file_read(smx_simcall_t simcall, smx_file_t fd, sg_size_t size, smx_host_t host)
 {
 //SIMIX FILE READ
 void simcall_HANDLER_file_read(smx_simcall_t simcall, smx_file_t fd, sg_size_t size, smx_host_t host)
 {

-  smx_synchro_t synchro = SIMIX_file_read(simcall->issuer, fd, size, host);
+  smx_synchro_t synchro = SIMIX_file_read(fd, size, host);

   xbt_fifo_push(synchro->simcalls, simcall);
   simcall->issuer->waiting_synchro = synchro;
 }
 
   xbt_fifo_push(synchro->simcalls, simcall);
   simcall->issuer->waiting_synchro = synchro;
 }
 

-smx_synchro_t SIMIX_file_read(smx_process_t process, smx_file_t fd, sg_size_t size, smx_host_t host)
+smx_synchro_t SIMIX_file_read(smx_file_t fd, sg_size_t size, smx_host_t host)

 {
   smx_synchro_t synchro;
 
 {
   smx_synchro_t synchro;
 


@@ -86,12 +86,12 @@ smx_synchro_t SIMIX_file_read(smx_process_t process, smx_file_t fd, sg_size_t si
 //SIMIX FILE WRITE
 void simcall_HANDLER_file_write(smx_simcall_t simcall, smx_file_t fd, sg_size_t size, smx_host_t host)
 {
 //SIMIX FILE WRITE
 void simcall_HANDLER_file_write(smx_simcall_t simcall, smx_file_t fd, sg_size_t size, smx_host_t host)
 {

-  smx_synchro_t synchro = SIMIX_file_write(simcall->issuer, fd,  size, host);
+  smx_synchro_t synchro = SIMIX_file_write(fd,  size, host);

   xbt_fifo_push(synchro->simcalls, simcall);
   simcall->issuer->waiting_synchro = synchro;
 }
 
   xbt_fifo_push(synchro->simcalls, simcall);
   simcall->issuer->waiting_synchro = synchro;
 }
 

-smx_synchro_t SIMIX_file_write(smx_process_t process, smx_file_t fd, sg_size_t size, smx_host_t host)
+smx_synchro_t SIMIX_file_write(smx_file_t fd, sg_size_t size, smx_host_t host)

 {
   smx_synchro_t synchro;
 
 {
   smx_synchro_t synchro;
 


@@ -120,12 +120,12 @@ smx_synchro_t SIMIX_file_write(smx_process_t process, smx_file_t fd, sg_size_t s
 //SIMIX FILE OPEN
 void simcall_HANDLER_file_open(smx_simcall_t simcall, const char* fullpath, smx_host_t host)
 {
 //SIMIX FILE OPEN
 void simcall_HANDLER_file_open(smx_simcall_t simcall, const char* fullpath, smx_host_t host)
 {

-  smx_synchro_t synchro = SIMIX_file_open(simcall->issuer, fullpath, host);
+  smx_synchro_t synchro = SIMIX_file_open(fullpath, host);

   xbt_fifo_push(synchro->simcalls, simcall);
   simcall->issuer->waiting_synchro = synchro;
 }
 
   xbt_fifo_push(synchro->simcalls, simcall);
   simcall->issuer->waiting_synchro = synchro;
 }
 

-smx_synchro_t SIMIX_file_open(smx_process_t process, const char* fullpath, smx_host_t host)
+smx_synchro_t SIMIX_file_open(const char* fullpath, smx_host_t host)

 {
   smx_synchro_t synchro;
 
 {
   smx_synchro_t synchro;
 


@@ -154,12 +154,12 @@ smx_synchro_t SIMIX_file_open(smx_process_t process, const char* fullpath, smx_h
 //SIMIX FILE CLOSE
 void simcall_HANDLER_file_close(smx_simcall_t simcall, smx_file_t fd, smx_host_t host)
 {
 //SIMIX FILE CLOSE
 void simcall_HANDLER_file_close(smx_simcall_t simcall, smx_file_t fd, smx_host_t host)
 {

-  smx_synchro_t synchro = SIMIX_file_close(simcall->issuer, fd, host);
+  smx_synchro_t synchro = SIMIX_file_close(fd, host);

   xbt_fifo_push(synchro->simcalls, simcall);
   simcall->issuer->waiting_synchro = synchro;
 }
 
   xbt_fifo_push(synchro->simcalls, simcall);
   simcall->issuer->waiting_synchro = synchro;
 }
 

-smx_synchro_t SIMIX_file_close(smx_process_t process, smx_file_t fd, smx_host_t host)
+smx_synchro_t SIMIX_file_close(smx_file_t fd, smx_host_t host)

 {
   smx_synchro_t synchro;
 
 {
   smx_synchro_t synchro;
 


@@ -187,12 +187,7 @@ smx_synchro_t SIMIX_file_close(smx_process_t process, smx_file_t fd, smx_host_t
 
 
 //SIMIX FILE UNLINK
 
 
 //SIMIX FILE UNLINK

-int simcall_HANDLER_file_unlink(smx_simcall_t simcall, smx_file_t fd, smx_host_t host)
-{
-  return SIMIX_file_unlink(simcall->issuer, fd, host);
-}
-
-int SIMIX_file_unlink(smx_process_t process, smx_file_t fd, smx_host_t host)
+int SIMIX_file_unlink(smx_file_t fd, smx_host_t host)

 {
   /* check if the host is active */
   if (surf_resource_get_state(surf_workstation_resource_priv(host)) != SURF_RESOURCE_ON) {
 {
   /* check if the host is active */
   if (surf_resource_get_state(surf_workstation_resource_priv(host)) != SURF_RESOURCE_ON) {


@@ -286,9 +281,6 @@ sg_size_t SIMIX_storage_get_used_size(smx_process_t process, smx_storage_t stora
   return  surf_storage_get_used_size(storage);
 }
 
   return  surf_storage_get_used_size(storage);
 }
 

-xbt_dict_t simcall_HANDLER_storage_get_properties(smx_simcall_t simcall, smx_storage_t storage){
-  return SIMIX_storage_get_properties(storage);
-}

 xbt_dict_t SIMIX_storage_get_properties(smx_storage_t storage){
   xbt_assert((storage != NULL), "Invalid parameters (simix storage is NULL)");
   return surf_resource_get_properties(surf_storage_resource_priv(storage));
 xbt_dict_t SIMIX_storage_get_properties(smx_storage_t storage){
   xbt_assert((storage != NULL), "Invalid parameters (simix storage is NULL)");
   return surf_resource_get_properties(surf_storage_resource_priv(storage));


@@ -299,10 +291,6 @@ const char* SIMIX_storage_get_name(smx_storage_t storage){
   return sg_storage_name(storage);
 }
 
   return sg_storage_name(storage);
 }
 

-xbt_dict_t simcall_HANDLER_storage_get_content(smx_simcall_t simcall, smx_storage_t storage){
-  return SIMIX_storage_get_content(storage);
-}
-

 xbt_dict_t SIMIX_storage_get_content(smx_storage_t storage){
   xbt_assert((storage != NULL), "Invalid parameters (simix storage is NULL)");
   return surf_storage_get_content(storage);
 xbt_dict_t SIMIX_storage_get_content(smx_storage_t storage){
   xbt_assert((storage != NULL), "Invalid parameters (simix storage is NULL)");
   return surf_storage_get_content(storage);

diff --git a/src/simix/smx_io_private.h b/src/simix/smx_io_private.h
index 74bb1a4..1cc843d 100644 (file)
--- a/src/simix/smx_io_private.h
+++ b/src/simix/smx_io_private.h
@@ -22,19 +22,19 @@ static inline smx_storage_priv_t SIMIX_storage_priv(smx_storage_t storage){
 
 smx_storage_t SIMIX_storage_create(const char *name, void *storage, void *data);
 void SIMIX_storage_destroy(void *s);
 
 smx_storage_t SIMIX_storage_create(const char *name, void *storage, void *data);
 void SIMIX_storage_destroy(void *s);

-smx_synchro_t SIMIX_file_read(smx_process_t process, smx_file_t fd, sg_size_t size, smx_host_t host);
-smx_synchro_t SIMIX_file_write(smx_process_t process, smx_file_t fd, sg_size_t size, smx_host_t host);
-smx_synchro_t SIMIX_file_open(smx_process_t process, const char* fullpath, smx_host_t host);
-smx_synchro_t SIMIX_file_close(smx_process_t process, smx_file_t fd, smx_host_t host);
-int SIMIX_file_unlink(smx_process_t process, smx_file_t fd, smx_host_t host);
+smx_synchro_t SIMIX_file_read(smx_file_t fd, sg_size_t size, smx_host_t host);
+smx_synchro_t SIMIX_file_write(smx_file_t fd, sg_size_t size, smx_host_t host);
+smx_synchro_t SIMIX_file_open(const char* fullpath, smx_host_t host);
+smx_synchro_t SIMIX_file_close(smx_file_t fd, smx_host_t host);
+int SIMIX_file_unlink(smx_file_t fd, smx_host_t host);

 sg_size_t SIMIX_file_get_size(smx_process_t process, smx_file_t fd);
 sg_size_t SIMIX_file_tell(smx_process_t process, smx_file_t fd);
 xbt_dynar_t SIMIX_file_get_info(smx_process_t process, smx_file_t fd);
 int SIMIX_file_seek(smx_process_t process, smx_file_t fd, sg_offset_t offset, int origin);
 int SIMIX_file_move(smx_process_t process, smx_file_t fd, const char* fullpath);
 
 sg_size_t SIMIX_file_get_size(smx_process_t process, smx_file_t fd);
 sg_size_t SIMIX_file_tell(smx_process_t process, smx_file_t fd);
 xbt_dynar_t SIMIX_file_get_info(smx_process_t process, smx_file_t fd);
 int SIMIX_file_seek(smx_process_t process, smx_file_t fd, sg_offset_t offset, int origin);
 int SIMIX_file_move(smx_process_t process, smx_file_t fd, const char* fullpath);
 

-sg_size_t SIMIX_storage_get_free_size(smx_process_t process,smx_storage_t storage);
-sg_size_t SIMIX_storage_get_used_size(smx_process_t process,smx_storage_t storage);
+sg_size_t SIMIX_storage_get_free_size(smx_process_t process, smx_storage_t storage);
+sg_size_t SIMIX_storage_get_used_size(smx_process_t process, smx_storage_t storage);

 
 xbt_dict_t SIMIX_storage_get_properties(smx_storage_t storage);
 
 
 xbt_dict_t SIMIX_storage_get_properties(smx_storage_t storage);
 

diff --git a/src/simix/smx_network.c b/src/simix/smx_network.c
index 921aa00..089c68e 100644 (file)
--- a/src/simix/smx_network.c
+++ b/src/simix/smx_network.c
@@ -44,9 +44,6 @@ void SIMIX_network_exit(void)
 /*                           Rendez-Vous Points                               */
 /******************************************************************************/
 
 /*                           Rendez-Vous Points                               */
 /******************************************************************************/
 

-smx_rdv_t simcall_HANDLER_rdv_create(smx_simcall_t simcall, const char *name){
-  return SIMIX_rdv_create(name);
-}

 smx_rdv_t SIMIX_rdv_create(const char *name)
 {
   /* two processes may have pushed the same rdv_create simcall at the same time */
 smx_rdv_t SIMIX_rdv_create(const char *name)
 {
   /* two processes may have pushed the same rdv_create simcall at the same time */


@@ -67,9 +64,6 @@ smx_rdv_t SIMIX_rdv_create(const char *name)
   return rdv;
 }
 
   return rdv;
 }
 

-void simcall_HANDLER_rdv_destroy(smx_simcall_t simcall, smx_rdv_t rdv){
-  return SIMIX_rdv_destroy(rdv);
-}

 void SIMIX_rdv_destroy(smx_rdv_t rdv)
 {
   if (rdv->name)
 void SIMIX_rdv_destroy(smx_rdv_t rdv)
 {
   if (rdv->name)


@@ -97,9 +91,6 @@ smx_rdv_t SIMIX_rdv_get_by_name(const char *name)
   return xbt_dict_get_or_null(rdv_points, name);
 }
 
   return xbt_dict_get_or_null(rdv_points, name);
 }
 

-unsigned int simcall_HANDLER_rdv_comm_count_by_host(smx_simcall_t simcall, smx_rdv_t rdv, smx_host_t host){
-  return SIMIX_rdv_comm_count_by_host(rdv, host);
-}

 int SIMIX_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host)
 {
   smx_synchro_t comm = NULL;
 int SIMIX_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host)
 {
   smx_synchro_t comm = NULL;


@@ -114,17 +105,11 @@ int SIMIX_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host)
   return count;
 }
 
   return count;
 }
 

-smx_synchro_t simcall_HANDLER_rdv_get_head(smx_simcall_t simcall, smx_rdv_t rdv){
-  return SIMIX_rdv_get_head(rdv);
-}

 smx_synchro_t SIMIX_rdv_get_head(smx_rdv_t rdv)
 {
   return xbt_fifo_get_item_content(xbt_fifo_get_first_item(rdv->comm_fifo));
 }
 
 smx_synchro_t SIMIX_rdv_get_head(smx_rdv_t rdv)
 {
   return xbt_fifo_get_item_content(xbt_fifo_get_first_item(rdv->comm_fifo));
 }
 

-smx_process_t simcall_HANDLER_rdv_get_receiver(smx_simcall_t simcall, smx_rdv_t rdv){
-  return SIMIX_rdv_get_receiver(rdv);
-}

 /**
  *  \brief get the receiver (process associated to the mailbox)
  *  \param rdv The rendez-vous point
 /**
  *  \brief get the receiver (process associated to the mailbox)
  *  \param rdv The rendez-vous point


@@ -135,10 +120,6 @@ smx_process_t SIMIX_rdv_get_receiver(smx_rdv_t rdv)
   return rdv->permanent_receiver;
 }
 
   return rdv->permanent_receiver;
 }
 

-void simcall_HANDLER_rdv_set_receiver(smx_simcall_t simcall, smx_rdv_t rdv,
-                           smx_process_t process){
-  SIMIX_rdv_set_receiver(rdv, process);
-}

 /**
  *  \brief set the receiver of the rendez vous point to allow eager sends
  *  \param rdv The rendez-vous point
 /**
  *  \brief set the receiver of the rendez vous point to allow eager sends
  *  \param rdv The rendez-vous point


@@ -955,9 +936,6 @@ void SIMIX_post_comm(smx_synchro_t synchro)
   }
 }
 
   }
 }
 

-void simcall_HANDLER_comm_cancel(smx_simcall_t simcall, smx_synchro_t synchro){
-  SIMIX_comm_cancel(synchro);
-}

 void SIMIX_comm_cancel(smx_synchro_t synchro)
 {
   /* if the synchro is a waiting state means that it is still in a rdv */
 void SIMIX_comm_cancel(smx_synchro_t synchro)
 {
   /* if the synchro is a waiting state means that it is still in a rdv */


@@ -992,9 +970,6 @@ void SIMIX_comm_resume(smx_synchro_t synchro)
 
 /************* synchro Getters **************/
 
 
 /************* synchro Getters **************/
 

-double simcall_HANDLER_comm_get_remains(smx_simcall_t simcall, smx_synchro_t synchro){
-  return SIMIX_comm_get_remains(synchro);
-}

 /**
  *  \brief get the amount remaining from the communication
  *  \param synchro The communication
 /**
  *  \brief get the amount remaining from the communication
  *  \param synchro The communication


@@ -1025,17 +1000,11 @@ double SIMIX_comm_get_remains(smx_synchro_t synchro)
   return remains;
 }
 
   return remains;
 }
 

-e_smx_state_t simcall_HANDLER_comm_get_state(smx_simcall_t simcall, smx_synchro_t synchro){
-  return SIMIX_comm_get_state(synchro);
-}

 e_smx_state_t SIMIX_comm_get_state(smx_synchro_t synchro)
 {
   return synchro->state;
 }
 
 e_smx_state_t SIMIX_comm_get_state(smx_synchro_t synchro)
 {
   return synchro->state;
 }
 

-void* simcall_HANDLER_comm_get_src_data(smx_simcall_t simcall, smx_synchro_t synchro){
-  return SIMIX_comm_get_src_data(synchro);
-}

 /**
  *  \brief Return the user data associated to the sender of the communication
  *  \param synchro The communication
 /**
  *  \brief Return the user data associated to the sender of the communication
  *  \param synchro The communication


@@ -1046,9 +1015,6 @@ void* SIMIX_comm_get_src_data(smx_synchro_t synchro)
   return synchro->comm.src_data;
 }
 
   return synchro->comm.src_data;
 }
 

-void* simcall_HANDLER_comm_get_dst_data(smx_simcall_t simcall, smx_synchro_t synchro){
-  return SIMIX_comm_get_dst_data(synchro);
-}

 /**
  *  \brief Return the user data associated to the receiver of the communication
  *  \param synchro The communication
 /**
  *  \brief Return the user data associated to the receiver of the communication
  *  \param synchro The communication


@@ -1059,28 +1025,17 @@ void* SIMIX_comm_get_dst_data(smx_synchro_t synchro)
   return synchro->comm.dst_data;
 }
 
   return synchro->comm.dst_data;
 }
 

-smx_process_t simcall_HANDLER_comm_get_src_proc(smx_simcall_t simcall, smx_synchro_t synchro){
-  return SIMIX_comm_get_src_proc(synchro);
-}

 smx_process_t SIMIX_comm_get_src_proc(smx_synchro_t synchro)
 {
   return synchro->comm.src_proc;
 }
 
 smx_process_t SIMIX_comm_get_src_proc(smx_synchro_t synchro)
 {
   return synchro->comm.src_proc;
 }
 

-smx_process_t simcall_HANDLER_comm_get_dst_proc(smx_simcall_t simcall, smx_synchro_t synchro){
-  return SIMIX_comm_get_dst_proc(synchro);
-}

 smx_process_t SIMIX_comm_get_dst_proc(smx_synchro_t synchro)
 {
   return synchro->comm.dst_proc;
 }
 
 #ifdef HAVE_LATENCY_BOUND_TRACKING
 smx_process_t SIMIX_comm_get_dst_proc(smx_synchro_t synchro)
 {
   return synchro->comm.dst_proc;
 }
 
 #ifdef HAVE_LATENCY_BOUND_TRACKING

-int simcall_HANDLER_comm_is_latency_bounded(smx_simcall_t simcall, smx_synchro_t synchro)
-{
-  return SIMIX_comm_is_latency_bounded(synchro);
-}
-

 /**
  *  \brief verify if communication is latency bounded
  *  \param comm The communication
 /**
  *  \brief verify if communication is latency bounded
  *  \param comm The communication

diff --git a/src/simix/smx_process.c b/src/simix/smx_process.c
index c70f33a..a0bcac1 100644 (file)
--- a/src/simix/smx_process.c
+++ b/src/simix/smx_process.c
@@ -38,9 +38,6 @@ int SIMIX_process_has_pending_comms(smx_process_t process) {
   return xbt_fifo_size(process->comms) > 0;
 }
 
   return xbt_fifo_size(process->comms) > 0;
 }
 

-void simcall_HANDLER_process_cleanup(smx_simcall_t simcall, smx_process_t process) {
-  SIMIX_process_cleanup(process);
-}

 /**
  * \brief Moves a process to the list of processes to destroy.
  */
 /**
  * \brief Moves a process to the list of processes to destroy.
  */


@@ -588,18 +585,11 @@ int SIMIX_process_get_maxpid(void) {
   return simix_process_maxpid;
 }
 
   return simix_process_maxpid;
 }
 

-int simcall_HANDLER_process_count(smx_simcall_t simcall){
-  return SIMIX_process_count();
-}

 int SIMIX_process_count(void)
 {
   return xbt_swag_size(simix_global->process_list);
 }
 
 int SIMIX_process_count(void)
 {
   return xbt_swag_size(simix_global->process_list);
 }
 

-int simcall_HANDLER_process_get_PID(smx_simcall_t simcall, smx_process_t self){
-   return SIMIX_process_get_PID(self);
-}
-

 int SIMIX_process_get_PID(smx_process_t self){
   if (self == NULL)
     return 0;
 int SIMIX_process_get_PID(smx_process_t self){
   if (self == NULL)
     return 0;


@@ -607,10 +597,6 @@ int SIMIX_process_get_PID(smx_process_t self){
     return self->pid;
 }
 
     return self->pid;
 }
 

-int simcall_HANDLER_process_get_PPID(smx_simcall_t simcall, smx_process_t self){
-  return SIMIX_process_get_PPID(self);
-}
-

 int SIMIX_process_get_PPID(smx_process_t self){
   if (self == NULL)
     return 0;
 int SIMIX_process_get_PPID(smx_process_t self){
   if (self == NULL)
     return 0;


@@ -628,10 +614,6 @@ void* SIMIX_process_self_get_data(smx_process_t self)
   return SIMIX_process_get_data(self);
 }
 
   return SIMIX_process_get_data(self);
 }
 

-void simcall_HANDLER_process_set_data(smx_simcall_t simcall, smx_process_t process,
-                                void *data){
-  SIMIX_process_set_data(process, data);
-}

 void SIMIX_process_self_set_data(smx_process_t self, void *data)
 {
   xbt_assert(self == SIMIX_process_self(), "This is not the current process");
 void SIMIX_process_self_set_data(smx_process_t self, void *data)
 {
   xbt_assert(self == SIMIX_process_self(), "This is not the current process");


@@ -639,9 +621,6 @@ void SIMIX_process_self_set_data(smx_process_t self, void *data)
   SIMIX_process_set_data(self, data);
 }
 
   SIMIX_process_set_data(self, data);
 }
 

-void* simcall_HANDLER_process_get_data(smx_simcall_t simcall, smx_process_t process){
-  return SIMIX_process_get_data(process);
-}

 void* SIMIX_process_get_data(smx_process_t process)
 {
   return process->data;
 void* SIMIX_process_get_data(smx_process_t process)
 {
   return process->data;


@@ -652,9 +631,6 @@ void SIMIX_process_set_data(smx_process_t process, void *data)
   process->data = data;
 }
 
   process->data = data;
 }
 

-smx_host_t simcall_HANDLER_process_get_host(smx_simcall_t simcall, smx_process_t process){
-  return SIMIX_process_get_host(process);
-}

 smx_host_t SIMIX_process_get_host(smx_process_t process)
 {
   return process->smx_host;
 smx_host_t SIMIX_process_get_host(smx_process_t process)
 {
   return process->smx_host;


@@ -671,9 +647,6 @@ const char* SIMIX_process_self_get_name(void) {
   return SIMIX_process_get_name(process);
 }
 
   return SIMIX_process_get_name(process);
 }
 

-const char* simcall_HANDLER_process_get_name(smx_simcall_t simcall, smx_process_t process) {
-  return SIMIX_process_get_name(process);
-}

 const char* SIMIX_process_get_name(smx_process_t process)
 {
   return process->name;
 const char* SIMIX_process_get_name(smx_process_t process)
 {
   return process->name;


@@ -691,17 +664,11 @@ smx_process_t SIMIX_process_get_by_name(const char* name)
   return NULL;
 }
 
   return NULL;
 }
 

-int simcall_HANDLER_process_is_suspended(smx_simcall_t simcall, smx_process_t process){
-  return SIMIX_process_is_suspended(process);
-}

 int SIMIX_process_is_suspended(smx_process_t process)
 {
   return process->suspended;
 }
 
 int SIMIX_process_is_suspended(smx_process_t process)
 {
   return process->suspended;
 }
 

-xbt_dict_t simcall_HANDLER_process_get_properties(smx_simcall_t simcall, smx_process_t process){
-  return SIMIX_process_get_properties(process);
-}

 xbt_dict_t SIMIX_process_get_properties(smx_process_t process)
 {
   return process->properties;
 xbt_dict_t SIMIX_process_get_properties(smx_process_t process)
 {
   return process->properties;


@@ -959,11 +926,6 @@ void SIMIX_process_on_exit_runall(smx_process_t process) {
   }
 }
 
   }
 }
 

-void simcall_HANDLER_process_on_exit(smx_simcall_t simcall, smx_process_t process,
-                              int_f_pvoid_pvoid_t fun, void *data) {
-  SIMIX_process_on_exit(process, fun, data);
-}
-

 void SIMIX_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void *data) {
   xbt_assert(process, "current process not found: are you in maestro context ?");
 
 void SIMIX_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void *data) {
   xbt_assert(process, "current process not found: are you in maestro context ?");
 


@@ -976,10 +938,6 @@ void SIMIX_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void
   xbt_dynar_push_as(process->on_exit,s_smx_process_exit_fun_t,exit_fun);
 }
 
   xbt_dynar_push_as(process->on_exit,s_smx_process_exit_fun_t,exit_fun);
 }
 

-void simcall_HANDLER_process_auto_restart_set(smx_simcall_t simcall, smx_process_t process,
-                                       int auto_restart) {
-  SIMIX_process_auto_restart_set(process, auto_restart);
-}

 /**
  * \brief Sets the auto-restart status of the process.
  * If set to 1, the process will be automatically restarted when its host
 /**
  * \brief Sets the auto-restart status of the process.
  * If set to 1, the process will be automatically restarted when its host

diff --git a/src/simix/smx_synchro.c b/src/simix/smx_synchro.c
index 3937fd0..3f25efe 100644 (file)
--- a/src/simix/smx_synchro.c
+++ b/src/simix/smx_synchro.c
@@ -168,6 +168,9 @@ void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex)
   XBT_OUT();
 }
 
   XBT_OUT();
 }
 

+int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex){
+  return SIMIX_mutex_trylock(mutex, simcall->issuer);
+}

 /**
  * \brief Tries to lock a mutex.
  *
 /**
  * \brief Tries to lock a mutex.
  *


@@ -228,9 +231,6 @@ void SIMIX_mutex_unlock(smx_mutex_t mutex, smx_process_t issuer)
   XBT_OUT();
 }
 
   XBT_OUT();
 }
 

-void simcall_HANDLER_mutex_destroy(smx_simcall_t simcall, smx_mutex_t mutex){
-  SIMIX_mutex_destroy(mutex);
-}

 /**
  * \brief Destroys a mutex.
  *
 /**
  * \brief Destroys a mutex.
  *


@@ -249,9 +249,6 @@ void SIMIX_mutex_destroy(smx_mutex_t mutex)
 
 /********************************* Condition **********************************/
 
 
 /********************************* Condition **********************************/
 

-smx_cond_t simcall_HANDLER_cond_init(smx_simcall_t simcall){
-  return SIMIX_cond_init();
-}

 /**
  * \brief Initialize a condition.
  *
 /**
  * \brief Initialize a condition.
  *


@@ -320,9 +317,6 @@ static void _SIMIX_cond_wait(smx_cond_t cond, smx_mutex_t mutex, double timeout,
   XBT_OUT();
 }
 
   XBT_OUT();
 }
 

-void simcall_HANDLER_cond_signal(smx_simcall_t simcall, smx_cond_t cond){
-  SIMIX_cond_signal(cond);
-}

 /**
  * \brief Signalizes a condition.
  *
 /**
  * \brief Signalizes a condition.
  *


@@ -360,9 +354,6 @@ void SIMIX_cond_signal(smx_cond_t cond)
   XBT_OUT();
 }
 
   XBT_OUT();
 }
 

-void simcall_HANDLER_cond_broadcast(smx_simcall_t simcall, smx_cond_t cond){
-  SIMIX_cond_broadcast(cond);
-}

 /**
  * \brief Broadcasts a condition.
  *
 /**
  * \brief Broadcasts a condition.
  *


@@ -382,11 +373,8 @@ void SIMIX_cond_broadcast(smx_cond_t cond)
   XBT_OUT();
 }
 
   XBT_OUT();
 }
 

-void simcall_HANDLER_cond_destroy(smx_simcall_t simcall, smx_cond_t cond){
-  SIMIX_cond_destroy(cond);
-}

 /**
 /**

- * \brief Destroys a contidion.
+ * \brief Destroys a condition.

  *
  * Destroys and frees the condition's memory. 
  * \param cond A condition
  *
  * Destroys and frees the condition's memory. 
  * \param cond A condition


@@ -408,9 +396,6 @@ void SIMIX_cond_destroy(smx_cond_t cond)
 
 /******************************** Semaphores **********************************/
 #define SMX_SEM_NOLIMIT 99999
 
 /******************************** Semaphores **********************************/
 #define SMX_SEM_NOLIMIT 99999

-smx_sem_t simcall_HANDLER_sem_init(smx_simcall_t simcall, unsigned int value){
-  return SIMIX_sem_init(value);
-}

 /** @brief Initialize a semaphore */
 smx_sem_t SIMIX_sem_init(unsigned int value)
 {
 /** @brief Initialize a semaphore */
 smx_sem_t SIMIX_sem_init(unsigned int value)
 {


@@ -424,9 +409,6 @@ smx_sem_t SIMIX_sem_init(unsigned int value)
   return sem;
 }
 
   return sem;
 }
 

-void simcall_HANDLER_sem_destroy(smx_simcall_t simcall, smx_sem_t sem){
-  SIMIX_sem_destroy(sem);
-}

 /** @brief Destroys a semaphore */
 void SIMIX_sem_destroy(smx_sem_t sem)
 {
 /** @brief Destroys a semaphore */
 void SIMIX_sem_destroy(smx_sem_t sem)
 {

diff --git a/src/simix/smx_vm.c b/src/simix/smx_vm.c
index 9dcd99d..d2eab04 100644 (file)
--- a/src/simix/smx_vm.c
+++ b/src/simix/smx_vm.c
@@ -34,12 +34,6 @@ smx_host_t SIMIX_vm_create(const char *name, smx_host_t ind_phys_host)
 }
 
 
 }
 
 

-smx_host_t simcall_HANDLER_vm_create(smx_simcall_t simcall, const char *name, smx_host_t ind_phys_host)
-{
-  return SIMIX_vm_create(name, ind_phys_host);
-}
-
-

 /* works for VMs and PMs */
 static long host_get_ramsize(smx_host_t vm, int *overcommit)
 {
 /* works for VMs and PMs */
 static long host_get_ramsize(smx_host_t vm, int *overcommit)
 {


@@ -103,23 +97,11 @@ void SIMIX_vm_start(smx_host_t ind_vm)
 }
 
 
 }
 
 

-
-void simcall_HANDLER_vm_start(smx_simcall_t simcall, smx_host_t ind_vm)
-{
-  SIMIX_vm_start(ind_vm);
-}
-

 int SIMIX_vm_get_state(smx_host_t ind_vm)
 {
   return surf_resource_get_state(surf_workstation_resource_priv(ind_vm));
 }
 
 int SIMIX_vm_get_state(smx_host_t ind_vm)
 {
   return surf_resource_get_state(surf_workstation_resource_priv(ind_vm));
 }
 

-int simcall_HANDLER_vm_get_state(smx_simcall_t simcall, smx_host_t ind_vm)
-{
-  return SIMIX_vm_get_state(ind_vm);
-}
-
-

 /**
  * \brief Function to migrate a SIMIX VM host.
  *
 /**
  * \brief Function to migrate a SIMIX VM host.
  *


@@ -134,12 +116,6 @@ void SIMIX_vm_migrate(smx_host_t ind_vm, smx_host_t ind_dst_pm)
   surf_vm_workstation_migrate(ind_vm, ind_dst_pm);
 }
 
   surf_vm_workstation_migrate(ind_vm, ind_dst_pm);
 }
 

-void simcall_HANDLER_vm_migrate(smx_simcall_t simcall, smx_host_t ind_vm, smx_host_t ind_dst_pm)
-{
-  SIMIX_vm_migrate(ind_vm, ind_dst_pm);
-}
-
-

 /**
  * \brief Function to get the physical host of the given SIMIX VM host.
  *
 /**
  * \brief Function to get the physical host of the given SIMIX VM host.
  *


@@ -151,12 +127,6 @@ void *SIMIX_vm_get_pm(smx_host_t ind_vm)
   return surf_vm_workstation_get_pm(ind_vm);
 }
 
   return surf_vm_workstation_get_pm(ind_vm);
 }
 

-void *simcall_HANDLER_vm_get_pm(smx_simcall_t simcall, smx_host_t ind_vm)
-{
-  return SIMIX_vm_get_pm(ind_vm);
-}
-
-

 /**
  * \brief Function to set the CPU bound of the given SIMIX VM host.
  *
 /**
  * \brief Function to set the CPU bound of the given SIMIX VM host.
  *


@@ -169,12 +139,6 @@ void SIMIX_vm_set_bound(smx_host_t ind_vm, double bound)
   surf_vm_workstation_set_bound(ind_vm, bound);
 }
 
   surf_vm_workstation_set_bound(ind_vm, bound);
 }
 

-void simcall_HANDLER_vm_set_bound(smx_simcall_t simcall, smx_host_t ind_vm, double bound)
-{
-  SIMIX_vm_set_bound(ind_vm, bound);
-}
-
-

 /**
  * \brief Function to set the CPU affinity of the given SIMIX VM host.
  *
 /**
  * \brief Function to set the CPU affinity of the given SIMIX VM host.
  *


@@ -191,11 +155,6 @@ void SIMIX_vm_set_affinity(smx_host_t ind_vm, smx_host_t ind_pm, unsigned long m
   surf_vm_workstation_set_affinity(ind_vm, ind_pm, mask);
 }
 
   surf_vm_workstation_set_affinity(ind_vm, ind_pm, mask);
 }
 

-void simcall_HANDLER_vm_set_affinity(smx_simcall_t simcall, smx_host_t ind_vm, smx_host_t ind_pm, unsigned long mask)
-{
-  SIMIX_vm_set_affinity(ind_vm, ind_pm, mask);
-}
-

 
 /**
  * \brief Function to suspend a SIMIX VM host. This function stops the execution of the
 
 /**
  * \brief Function to suspend a SIMIX VM host. This function stops the execution of the


@@ -387,8 +346,3 @@ void SIMIX_vm_destroy(smx_host_t ind_vm)
   /* jump to vm_ws_destroy(). The surf level resource will be freed. */
   surf_vm_workstation_destroy(ind_vm);
 }
   /* jump to vm_ws_destroy(). The surf level resource will be freed. */
   surf_vm_workstation_destroy(ind_vm);
 }

-
-void simcall_HANDLER_vm_destroy(smx_simcall_t simcall, smx_host_t ind_vm)
-{
-  SIMIX_vm_destroy(ind_vm);
-}