X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/6c98d311c94b09a185a36f90f7a4a56a6a70298a..4b90ce2abff77ca7898fd9292a122440df739916:/src/simix/popping_bodies.cpp diff --git a/src/simix/popping_bodies.cpp b/src/simix/popping_bodies.cpp index 356a7b7c30..c659920331 100644 --- a/src/simix/popping_bodies.cpp +++ b/src/simix/popping_bodies.cpp @@ -4,7 +4,7 @@ /* DO NOT EVER CHANGE THIS FILE */ /* */ /* change simcalls specification in src/simix/simcalls.in */ -/* Copyright (c) 2014-2019. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2014-2020. The SimGrid Team. All rights reserved. */ /**********************************************************************/ /* @@ -28,167 +28,146 @@ template inline static R simcall(e_smx_simcall_t call, T const&... t) { smx_actor_t self = SIMIX_process_self(); - simgrid::simix::marshal(&self->simcall, call, t...); + simgrid::simix::marshal(&self->simcall_, call, t...); if (self != simix_global->maestro_) { - XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->get_cname(), SIMIX_simcall_name(self->simcall.call_), - (int)self->simcall.call_); + XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->get_cname(), SIMIX_simcall_name(self->simcall_.call_), + (int)self->simcall_.call_); self->yield(); } else { self->simcall_handle(0); } - return simgrid::simix::unmarshal(self->simcall.result_); -} - -inline static int simcall_BODY_execution_wait(simgrid::kernel::activity::ExecImpl* execution, double timeout) -{ - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_execution_wait(&SIMIX_process_self()->simcall, execution, timeout); - return simcall(SIMCALL_EXECUTION_WAIT, execution, timeout); + return simgrid::simix::unmarshal(self->simcall_.result_); } inline static int simcall_BODY_execution_waitany_for(simgrid::kernel::activity::ExecImpl** execs, size_t count, double timeout) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_execution_waitany_for(&SIMIX_process_self()->simcall, execs, count, timeout); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_execution_waitany_for(&SIMIX_process_self()->simcall_, execs, count, timeout); return simcall(SIMCALL_EXECUTION_WAITANY_FOR, execs, count, timeout); } -inline static bool simcall_BODY_execution_test(simgrid::kernel::activity::ExecImpl* execution) -{ - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_execution_test(&SIMIX_process_self()->simcall, execution); - return simcall(SIMCALL_EXECUTION_TEST, execution); -} - inline static void simcall_BODY_comm_send(smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, unsigned char* 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) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_comm_send(&SIMIX_process_self()->simcall, sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, copy_data_fun, data, timeout); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_comm_send(&SIMIX_process_self()->simcall_, sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, copy_data_fun, data, timeout); return simcall(SIMCALL_COMM_SEND, sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, copy_data_fun, data, timeout); } inline static boost::intrusive_ptr simcall_BODY_comm_isend(smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, unsigned char* 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, bool detached) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_comm_isend(&SIMIX_process_self()->simcall, sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, clean_fun, copy_data_fun, data, detached); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_comm_isend(&SIMIX_process_self()->simcall_, sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, clean_fun, copy_data_fun, data, detached); return simcall, smx_actor_t, smx_mailbox_t, double, double, unsigned char*, size_t, simix_match_func_t, simix_clean_func_t, simix_copy_data_func_t, void*, bool>(SIMCALL_COMM_ISEND, sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, clean_fun, copy_data_fun, data, detached); } inline static void simcall_BODY_comm_recv(smx_actor_t receiver, smx_mailbox_t mbox, unsigned char* 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) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_comm_recv(&SIMIX_process_self()->simcall, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, timeout, rate); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_comm_recv(&SIMIX_process_self()->simcall_, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, timeout, rate); return simcall(SIMCALL_COMM_RECV, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, timeout, rate); } inline static boost::intrusive_ptr simcall_BODY_comm_irecv(smx_actor_t receiver, smx_mailbox_t mbox, unsigned char* 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) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_comm_irecv(&SIMIX_process_self()->simcall, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_comm_irecv(&SIMIX_process_self()->simcall_, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate); return simcall, smx_actor_t, smx_mailbox_t, unsigned char*, size_t*, simix_match_func_t, simix_copy_data_func_t, void*, double>(SIMCALL_COMM_IRECV, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate); } inline static int simcall_BODY_comm_waitany(simgrid::kernel::activity::CommImpl** comms, size_t count, double timeout) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_comm_waitany(&SIMIX_process_self()->simcall, comms, count, timeout); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_comm_waitany(&SIMIX_process_self()->simcall_, comms, count, timeout); return simcall(SIMCALL_COMM_WAITANY, comms, count, timeout); } inline static void simcall_BODY_comm_wait(simgrid::kernel::activity::CommImpl* comm, double timeout) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_comm_wait(&SIMIX_process_self()->simcall, comm, timeout); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_comm_wait(&SIMIX_process_self()->simcall_, comm, timeout); return simcall(SIMCALL_COMM_WAIT, comm, timeout); } inline static bool simcall_BODY_comm_test(simgrid::kernel::activity::CommImpl* comm) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_comm_test(&SIMIX_process_self()->simcall, comm); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_comm_test(&SIMIX_process_self()->simcall_, comm); return simcall(SIMCALL_COMM_TEST, comm); } inline static int simcall_BODY_comm_testany(simgrid::kernel::activity::CommImpl** comms, size_t count) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_comm_testany(&SIMIX_process_self()->simcall, comms, count); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_comm_testany(&SIMIX_process_self()->simcall_, comms, count); return simcall(SIMCALL_COMM_TESTANY, comms, count); } inline static void simcall_BODY_mutex_lock(smx_mutex_t mutex) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_mutex_lock(&SIMIX_process_self()->simcall, mutex); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_mutex_lock(&SIMIX_process_self()->simcall_, mutex); return simcall(SIMCALL_MUTEX_LOCK, mutex); } inline static int simcall_BODY_mutex_trylock(smx_mutex_t mutex) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_mutex_trylock(&SIMIX_process_self()->simcall, mutex); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_mutex_trylock(&SIMIX_process_self()->simcall_, mutex); return simcall(SIMCALL_MUTEX_TRYLOCK, mutex); } inline static void simcall_BODY_mutex_unlock(smx_mutex_t mutex) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_mutex_unlock(&SIMIX_process_self()->simcall, mutex); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_mutex_unlock(&SIMIX_process_self()->simcall_, mutex); return simcall(SIMCALL_MUTEX_UNLOCK, mutex); } inline static void simcall_BODY_cond_wait(smx_cond_t cond, smx_mutex_t mutex) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_cond_wait(&SIMIX_process_self()->simcall, cond, mutex); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_cond_wait(&SIMIX_process_self()->simcall_, cond, mutex); return simcall(SIMCALL_COND_WAIT, cond, mutex); } inline static int simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_cond_wait_timeout(&SIMIX_process_self()->simcall, cond, mutex, timeout); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_cond_wait_timeout(&SIMIX_process_self()->simcall_, cond, mutex, timeout); return simcall(SIMCALL_COND_WAIT_TIMEOUT, cond, mutex, timeout); } inline static void simcall_BODY_sem_acquire(smx_sem_t sem) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_sem_acquire(&SIMIX_process_self()->simcall, sem); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_sem_acquire(&SIMIX_process_self()->simcall_, sem); return simcall(SIMCALL_SEM_ACQUIRE, sem); } inline static int simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_sem_acquire_timeout(&SIMIX_process_self()->simcall, sem, timeout); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_sem_acquire_timeout(&SIMIX_process_self()->simcall_, sem, timeout); return simcall(SIMCALL_SEM_ACQUIRE_TIMEOUT, sem, timeout); } -inline static sg_size_t simcall_BODY_io_wait(simgrid::kernel::activity::IoImpl* io, double timeout) -{ - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_io_wait(&SIMIX_process_self()->simcall, io, timeout); - return simcall(SIMCALL_IO_WAIT, io, timeout); -} - inline static int simcall_BODY_mc_random(int min, int max) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ - simcall_HANDLER_mc_random(&SIMIX_process_self()->simcall, min, max); + if (false) /* Go to that function to follow the code flow through the simcall barrier */ + simcall_HANDLER_mc_random(&SIMIX_process_self()->simcall_, min, max); return simcall(SIMCALL_MC_RANDOM, min, max); } inline static void simcall_BODY_run_kernel(std::function const* code) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ + if (false) /* Go to that function to follow the code flow through the simcall barrier */ SIMIX_run_kernel(code); return simcall const*>(SIMCALL_RUN_KERNEL, code); } inline static void simcall_BODY_run_blocking(std::function const* code) { - if (0) /* Go to that function to follow the code flow through the simcall barrier */ + if (false) /* Go to that function to follow the code flow through the simcall barrier */ SIMIX_run_blocking(code); return simcall const*>(SIMCALL_RUN_BLOCKING, code); }