[popping] allow to omit the handler

simcalls handlers are good to get extra arguments from the simcall
(such as the issuer) or to check the parameters, but when there is no
such thing to do, they just load the picture for nothing.

diff --git a/doc/doxygen/inside_extending.doc b/doc/doxygen/inside_extending.doc
index 8dfd212..bb37b1d 100644 (file)
--- a/doc/doxygen/inside_extending.doc
+++ b/doc/doxygen/inside_extending.doc
@@ -138,6 +138,12 @@ The workflow of a simcall is the following:
      It is thus the responsability of the blocking simcalls to call
      `SIMIX_simcall_answer(simcall)` themselves in their handler.
 
+Note that empty HANDLERs can be omitted. These functions usually do
+some parameter checking, or retrieve some information about the
+simcall issuer, but when there no need for such things, the handler
+can be omited. In that case, we directly call the function
+`simcall_<name>(<args>)`.
+
 To simplify the simcall creation, a python script generates most of
 the code and give helpers for the remaining stuff. That script reads
 the simcall definitions from src/simix/simcalls.in, checks that both

diff --git a/src/simix/popping_accessors.h b/src/simix/popping_accessors.h
index 544f860..ef08012 100644 (file)
--- a/src/simix/popping_accessors.h
+++ b/src/simix/popping_accessors.h
@@ -1970,7 +1970,7 @@ smx_process_t simcall_HANDLER_comm_get_dst_proc(smx_simcall_t simcall, smx_synch
 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);
-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);
 smx_cond_t simcall_HANDLER_cond_init(smx_simcall_t simcall);
 void simcall_HANDLER_cond_destroy(smx_simcall_t simcall, smx_cond_t cond);

diff --git a/src/simix/popping_bodies.c b/src/simix/popping_bodies.c
index 20e58e2..f0effd3 100644 (file)
--- a/src/simix/popping_bodies.c
+++ b/src/simix/popping_bodies.c
@@ -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 */
-    if (0) simcall_HANDLER_mutex_trylock(&self->simcall, mutex);
+    if (0) simcall_mutex_trylock(mutex);
     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 
     self->simcall.call = SIMCALL_MUTEX_TRYLOCK;

diff --git a/src/simix/popping_generated.c b/src/simix/popping_generated.c
index 16d6247..a6cfb76 100644 (file)
--- a/src/simix/popping_generated.c
+++ b/src/simix/popping_generated.c
@@ -597,7 +597,7 @@ case SIMCALL_MUTEX_LOCK:
        break;  
 
 case SIMCALL_MUTEX_TRYLOCK:
-      simcall->result.i = simcall_HANDLER_mutex_trylock(simcall , (smx_mutex_t) simcall->args[0].dp);
+      simcall->result.i = simcall_mutex_trylock((smx_mutex_t) simcall->args[0].dp);
       SIMIX_simcall_answer(simcall);
       break;  
 

diff --git a/src/simix/simcalls.in b/src/simix/simcalls.in
index acbe56d..8a433a0 100644 (file)
--- a/src/simix/simcalls.in
+++ b/src/simix/simcalls.in
@@ -3,136 +3,138 @@
 # This program is free software; you can redistribute it and/or modify it
 # under the terms of the license (GNU LGPL) which comes with this package.
 
-# CallType name (resulttype,resultcast) (arg0name,arg0type,arg0cast) (arg1name,arg1type,arg1cast)
+# CallType handler? name (resulttype,resultcast) (arg0name,arg0type,arg0cast) (arg1name,arg1type,arg1cast)
 
 # CallType must be one of the three:
 #  - Func: returning a value immediately
 #  - Blck: Blocking call that does not return in the same scheduling round
 #  - Proc: not returning any value (but doing so immediately) 
 
-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 host_off (void) (host, void*, smx_host_t)
-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 host_execution_wait (int) (execution, void*, smx_synchro_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 vm_suspend (void) (ind_vm, void*, smx_host_t)
-Proc vm_resume (void) (ind_vm, void*, smx_host_t)
-Proc vm_shutdown (void) (ind_vm, void*, smx_host_t)
-Proc vm_save (void) (ind_vm, void*, smx_host_t)
-Proc vm_restore (void) (ind_vm, void*, smx_host_t)
-Proc 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 process_kill (void) (process, void*, smx_process_t)
-Proc process_killall (void) (reset_pid, int)
-Proc process_cleanup (void) (process, void*, smx_process_t)
-Proc process_change_host (void) (process, void*, smx_process_t) (dest, void*, smx_host_t)
-Blck process_suspend (void) (process, void*, smx_process_t)
-Proc process_resume (void) (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 process_join (int) (process, void*, smx_process_t) (timeout, double)
-Blck process_sleep (int) (duration, double)
-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 process_restart (void*, smx_process_t) (process, void*, smx_process_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 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 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 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 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 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 comm_cancel (void) (comm, void*, smx_synchro_t)
-Blck comm_waitany (int) (comms, void*, xbt_dynar_t)
-Blck comm_wait (void) (comm, void*, smx_synchro_t) (timeout, double)
-Blck comm_test (int) (comm, void*, smx_synchro_t)
-Blck comm_testany (int) (comms, void*, xbt_dynar_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 mutex_init (void*, smx_mutex_t)
-Proc mutex_destroy (void) (mutex, void*, smx_mutex_t)
-Blck mutex_lock (void) (mutex, void*, smx_mutex_t)
-Func mutex_trylock (int) (mutex, void*, smx_mutex_t)
-Proc mutex_unlock (void) (mutex, void*, smx_mutex_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 cond_wait (void) (cond, void*, smx_cond_t) (mutex, void*, smx_mutex_t)
-Blck cond_wait_timeout (void) (cond, void*, smx_cond_t) (mutex, void*, smx_mutex_t) (timeout, double)
-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 sem_release (void) (sem, void*, smx_sem_t)
-Func sem_would_block (int) (sem, void*, smx_sem_t)
-Blck sem_acquire (void) (sem, void*, smx_sem_t)
-Blck sem_acquire_timeout (void) (sem, void*, smx_sem_t) (timeout, double)
-Func sem_get_capacity (int) (sem, void*, smx_sem_t)
-Blck file_read (sg_size_t) (fd, void*, smx_file_t) (size, sg_size_t) (host, void*, smx_host_t)
-Blck file_write (sg_size_t) (fd, void*, smx_file_t) (size, sg_size_t) (host, void*, smx_host_t)
-Blck file_open (void*, smx_file_t) (fullpath, const char*) (host, void*, smx_host_t)
-Blck file_close (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 file_get_size (sg_size_t) (fd, void*, smx_file_t)
-Func file_tell (sg_size_t) (fd, void*, smx_file_t)
-Func file_seek (int) (fd, void*, smx_file_t) (offset, sg_offset_t) (origin, int)
-Func file_get_info (void*, xbt_dynar_t) (fd, void*, smx_file_t)
-Func file_move (int) (fd, void*, smx_file_t) (fullpath, const char*)
-Func storage_get_free_size (sg_size_t) (storage, void*, smx_storage_t)
-Func storage_get_used_size (sg_size_t) (name, 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 asr_get_properties (void*, xbt_dict_t) (name, const char*)
+# 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)
+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)
+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)
+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_save (void) (ind_vm, void*, smx_host_t)
+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_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)
+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)
+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)
+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 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)
+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 H mutex_init (void*, smx_mutex_t)
+Proc H mutex_destroy (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)
+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)
+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 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)
+Blck H sem_acquire_timeout (void) (sem, void*, smx_sem_t) (timeout, double)
+Func H sem_get_capacity (int) (sem, void*, smx_sem_t)
+Blck H file_read (sg_size_t) (fd, void*, smx_file_t) (size, sg_size_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 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_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 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 H asr_get_properties (void*, xbt_dict_t) (name, const char*)
 ## HAVE_LATENCY_BOUND_TRACKING
-Func comm_is_latency_bounded (int) (comm, void*, smx_synchro_t)
+Func H comm_is_latency_bounded (int) (comm, void*, smx_synchro_t)
 ## HAVE_TRACING
-Proc set_category (void) (synchro, void*, smx_synchro_t) (category, const char*)
+Proc H set_category (void) (synchro, void*, smx_synchro_t) (category, const char*)
 ## HAVE_MC
-Func mc_snapshot (void*, mc_snapshot_t)
-Func mc_compare_snapshots (int) (s1, void*, mc_snapshot_t) (s2, void*, mc_snapshot_t)
-Func mc_random (int) (min, int) (max, int)
+Func H mc_snapshot (void*, mc_snapshot_t)
+Func H mc_compare_snapshots (int) (s1, void*, mc_snapshot_t) (s2, void*, mc_snapshot_t)
+Func H mc_random (int) (min, int) (max, int)

diff --git a/src/simix/simcalls.py b/src/simix/simcalls.py
index 0861c1f..a4eaa32 100755 (executable)
--- a/src/simix/simcalls.py
+++ b/src/simix/simcalls.py
@@ -48,10 +48,11 @@ class Arg(object):
 class Simcall(object):
   simcalls_BODY = None
   simcalls_PRE = None
-  def __init__(self, name, res, args, call_kind):
+  def __init__(self, name, handler, res, args, call_kind):
     self.name = name
     self.res = res
     self.args = args
+    self.need_handler = handler
     self.call_kind = call_kind
 
   def check(self):
@@ -75,16 +76,22 @@ class Simcall(object):
             f = open(fn)
             self.simcalls_PRE |= set(re.findall('simcall_HANDLER_(.*?)\(', f.read()))
             f.close()
-      if self.name not in self.simcalls_PRE:
-          print '# ERROR: No function called simcall_HANDLER_%s'%self.name
-          print '# Add something like this to the relevant C file (like smx_io.c if it\'s an IO call):'
-          print '%s simcall_HANDLER_%s(smx_simcall_t simcall%s) {'%(self.res.rettype()
-                                                                    ,self.name                                               
-                                                                    ,''.join(', %s %s'%(arg.rettype(), arg.name)
+      if self.need_handler:
+          if (self.name not in self.simcalls_PRE):
+              print '# ERROR: No function called simcall_HANDLER_%s'%self.name
+              print '# Add something like this to the relevant C file (like smx_io.c if it\'s an IO call):'
+              print '%s simcall_HANDLER_%s(smx_simcall_t simcall%s) {'%(self.res.rettype()
+                                                                        ,self.name                                               
+                                                                        ,''.join(', %s %s'%(arg.rettype(), arg.name)
                                                                              for arg in self.args))
-          print '  // Your code handling the simcall'
-          print '}'
-          return False
+              print '  // Your code handling the simcall'
+              print '}'
+              return False
+      else:
+          if (self.name in self.simcalls_PRE):
+              print '# ERROR: You have a function called simcall_HANDLER_%s, but that simcall is not using any handler'%self.name
+              print '# Either change your simcall definition, or kill that function'
+              return False
       return True
 
   def enum(self):
@@ -117,51 +124,65 @@ class Simcall(object):
     return '\n'.join(res)
 
   def case(self):
-    return '''case SIMCALL_%s:
-      %ssimcall_HANDLER_%s(simcall %s);
-      %sbreak;  
-'''%(self.name.upper(), 
-     '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)),
-     'SIMIX_simcall_answer(simcall);\n      ' if self.call_kind != 'Blck' else ' ')
+      res = []
+      res.append('case SIMCALL_%s:'%(self.name.upper()))
+      if self.need_handler:
+          res.append('      %ssimcall_HANDLER_%s(simcall %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))))
+      else:
+          res.append('      %ssimcall_%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))))
+      res.append('      %sbreak;  \n'%('SIMIX_simcall_answer(simcall);\n      ' if self.call_kind != 'Blck' else ' '))  
+      return '\n'.join(res)
 
   def body(self):
-    return '''  
-inline static %s simcall_BODY_%s(%s) {
-    smx_process_t self = SIMIX_process_self();
-
-    /* Go to that function to follow the code flow through the simcall barrier */
-    if (0) simcall_HANDLER_%s(%s);
-    /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
+      res = ['  ']
+      res.append('inline static %s simcall_BODY_%s(%s) {'%(self.res.rettype(),
+                                                           self.name,
+                                                           ', '.join('%s %s'%(arg.rettype(), arg.name) for arg in self.args)))
+      res.append('    smx_process_t self = SIMIX_process_self();')
+      res.append('')
+      res.append('    /* Go to that function to follow the code flow through the simcall barrier */')
+      if self.need_handler:
+          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,
+                                                   ', '.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('')
+      res.append('    self->simcall.call = SIMCALL_%s;'%(self.name.upper()))
+      res.append('    memset(&self->simcall.result, 0, sizeof(self->simcall.result));')
+      res.append('    memset(self->simcall.args, 0, sizeof(self->simcall.args));')
+      res.append('\n'.join('    self->simcall.args[%d].%s = (%s) %s;'%(i, arg.field(), arg.type, arg.name)
+                  for i, arg in enumerate(self.args)))
+      res.append('    if (self != simix_global->maestro_process) {')
+      res.append('      XBT_DEBUG("Yield process \'%s\' on simcall %s (%d)", self->name,')
+      res.append('                SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);')
+      res.append('      SIMIX_process_yield(self);')
+      res.append('    } else {')
+      res.append('      SIMIX_simcall_handle(&self->simcall, 0);')
+      res.append('    }    ')   
+      if self.res.type != 'void':
+          res.append('    return self->simcall.result.%s;'%self.res.field())
+      else:
+          res.append('    ')
+      res.append('  }')
+      return '\n'.join(res)
 
-    self->simcall.call = SIMCALL_%s;
-    memset(&self->simcall.result, 0, sizeof(self->simcall.result));
-    memset(self->simcall.args, 0, sizeof(self->simcall.args));
-%s
-    if (self != simix_global->maestro_process) {
-      XBT_DEBUG("Yield process '%%s' on simcall %%s (%%d)", self->name,
-                SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
-      SIMIX_process_yield(self);
-    } else {
-      SIMIX_simcall_handle(&self->simcall, 0);
-    }    
-    %s
-  }'''%(self.res.rettype()
-       ,self.name
-       ,', '.join('%s %s'%(arg.rettype(), arg.name)
-                  for arg in self.args)
-       ,self.name
-       ,', '.join(["&self->simcall"]+ [arg.name for arg in self.args])
-       ,self.name.upper()
-       ,'\n'.join('    self->simcall.args[%d].%s = (%s) %s;'%(i, arg.field(), arg.type, arg.name)
-                  for i, arg in enumerate(self.args))
-       ,'' if self.res.type == 'void' else 'return self->simcall.result.%s;'%self.res.field())
-  
+      
   def handler_prototype(self):
-      return "%s simcall_HANDLER_%s(smx_simcall_t simcall%s);"%(self.res.rettype() if self.call_kind == 'Func' else 'void', self.name, ''.join(', %s %s'%(arg.rettype(), arg.name) 
-             for i, arg in enumerate(self.args)))
+      if self.need_handler:
+          return "%s simcall_HANDLER_%s(smx_simcall_t simcall%s);"%(self.res.rettype() if self.call_kind == 'Func' else 'void', 
+                                                                    self.name, 
+                                                                    ''.join(', %s %s'%(arg.rettype(), arg.name) 
+                    for i, arg in enumerate(self.args)))
+      else:
+          return ""
 
 def parse(fn):
   simcalls = []
@@ -173,14 +194,15 @@ def parse(fn):
       simcalls_guarded[re.search(r'## *(.*)', line).group(1)] = resdi
     if line.startswith('#') or not line:
       continue
-    match = re.match(r'(\S*?) *(\S*?) *\((.*?)(?:, *(.*?))?\) *(.*)', line)
+    match = re.match(r'(\S*?) *(\S*?) *(\S*?) *\((.*?)(?:, *(.*?))?\) *(.*)', line)
     assert match, line
-    ans, name, rest, resc, args = match.groups()
+    ans, handler, name, rest, resc, args = match.groups()
     assert (ans == 'Proc' or ans == 'Func' or ans == 'Blck'),"Invalid call type: '%s'. Faulty line:\n%s\n"%(ans,line)
+    assert (handler == 'H' or handler == '-'),"Invalid need_handler indication: '%s'. Faulty line:\n%s\n"%(handler,line)
     sargs = []
     for n,t,c in re.findall(r'\((.*?), *(.*?)(?:, *(.*?))?\)', args):
       sargs.append(Arg(n,t,c))
-    sim = Simcall(name, Arg('result', rest, resc), sargs, ans)
+    sim = Simcall(name, handler=='H', Arg('result', rest, resc), sargs, ans)
     if resdi is None:
       simcalls.append(sim)
     else:

diff --git a/src/simix/smx_synchro.c b/src/simix/smx_synchro.c
index efbb1d6..3937fd0 100644 (file)
--- a/src/simix/smx_synchro.c
+++ b/src/simix/smx_synchro.c
@@ -168,9 +168,6 @@ void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex)
   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.
  *