/* 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);
-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);
-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_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);
-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_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_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);
-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);
-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);
-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);
-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_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_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);
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
-int simcall_HANDLER_comm_is_latency_bounded(smx_simcall_t simcall, smx_synchro_t comm);
+
#endif
#ifdef HAVE_TRACING
-void simcall_HANDLER_set_category(smx_simcall_t simcall, smx_synchro_t synchro, const char* category);
+
#endif
#ifdef HAVE_MC
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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:
- 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:
- 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;
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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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;
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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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;
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;
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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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:
- 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;
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:
- 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;
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:
- 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:
- 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:
- 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:
- 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:
- 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;
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;
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:
- 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:
- 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:
- 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:
- 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:
- 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;
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;
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;
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:
- 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:
- 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;
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:
- 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:
- 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;
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;
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:
- 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;
#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;
#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;
# 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)
-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)
-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 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)
-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)
-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 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)
-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)
-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)
-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)
-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)
-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)
-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)
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_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 comm_is_latency_bounded (int) (comm, void*, smx_synchro_t)
+Func - comm_is_latency_bounded (int) (comm, void*, smx_synchro_t)
## 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)
''.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))))
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('')
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))
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
*
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);
}
/**
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);*/
}
/**
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)),
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);
}
-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));
}
-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);
}
-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);
}
-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);
}
-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 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 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);
}
-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)");
}
-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);
}
-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);
}
-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)");
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){
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,
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);
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);
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;
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;
}
-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 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 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);
#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;
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 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_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)");
//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;
}
-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;
//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;
}
-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;
//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;
}
-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;
//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;
}
-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;
//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) {
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));
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);
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_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);
/* 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 */
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)
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;
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_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
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
}
}
-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 */
/************* 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
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;
}
-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
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
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 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
-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
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.
*/
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 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;
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;
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");
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;
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;
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;
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;
}
-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;
}
}
-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 ?");
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
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.
*
XBT_OUT();
}
-void simcall_HANDLER_mutex_destroy(smx_simcall_t simcall, smx_mutex_t mutex){
- SIMIX_mutex_destroy(mutex);
-}
/**
* \brief Destroys a mutex.
*
/********************************* Condition **********************************/
-smx_cond_t simcall_HANDLER_cond_init(smx_simcall_t simcall){
- return SIMIX_cond_init();
-}
/**
* \brief Initialize a condition.
*
XBT_OUT();
}
-void simcall_HANDLER_cond_signal(smx_simcall_t simcall, smx_cond_t cond){
- SIMIX_cond_signal(cond);
-}
/**
* \brief Signalizes a condition.
*
XBT_OUT();
}
-void simcall_HANDLER_cond_broadcast(smx_simcall_t simcall, smx_cond_t cond){
- SIMIX_cond_broadcast(cond);
-}
/**
* \brief Broadcasts a condition.
*
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
/******************************** 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)
{
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)
{
}
-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)
{
}
-
-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 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.
*
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.
*
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.
*
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.
*
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
/* 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);
-}