X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/d0ac50e071a5fc760cd64d908b24ae1756dcf00e..905e26b959375a249abcfdf1599f6178fe031f44:/src/simix/libsmx.cpp diff --git a/src/simix/libsmx.cpp b/src/simix/libsmx.cpp index 115a0e8468..4d68d3d7d0 100644 --- a/src/simix/libsmx.cpp +++ b/src/simix/libsmx.cpp @@ -15,14 +15,17 @@ #include +#include + +#include + #include "src/mc/mc_replay.h" #include "smx_private.h" #include "src/mc/mc_forward.hpp" #include "xbt/ex.h" #include "mc/mc.h" #include "src/simix/smx_host_private.h" - -#include "src/simix/SynchroComm.hpp" +#include "src/kernel/activity/SynchroComm.hpp" #include @@ -107,7 +110,7 @@ smx_synchro_t simcall_execution_parallel_start(const char *name, /* checking for infinite values */ for (i = 0 ; i < host_nb ; ++i) { xbt_assert(std::isfinite(flops_amount[i]), "flops_amount[%d] is not finite!", i); - if (bytes_amount != NULL) { + if (bytes_amount != nullptr) { for (j = 0 ; j < host_nb ; ++j) { xbt_assert(std::isfinite(bytes_amount[i + host_nb * j]), "bytes_amount[%d+%d*%d] is not finite!", i, host_nb, j); @@ -203,7 +206,7 @@ e_smx_state_t simcall_execution_wait(smx_synchro_t execution) */ void* simcall_vm_create(const char *name, sg_host_t phys_host) { - return simgrid::simix::kernel(std::bind(SIMIX_vm_create, name, phys_host)); + return simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_create, name, phys_host)); } /** @@ -214,7 +217,7 @@ void* simcall_vm_create(const char *name, sg_host_t phys_host) */ void simcall_vm_start(sg_host_t vm) { - return simgrid::simix::kernel(std::bind(SIMIX_vm_start, vm)); + simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_start, vm)); } /** @@ -226,7 +229,7 @@ void simcall_vm_start(sg_host_t vm) */ int simcall_vm_get_state(sg_host_t vm) { - return simgrid::simix::kernel(std::bind(SIMIX_vm_get_state, vm)); + return simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_get_state, vm)); } /** @@ -238,17 +241,17 @@ int simcall_vm_get_state(sg_host_t vm) */ void *simcall_vm_get_pm(sg_host_t vm) { - return simgrid::simix::kernel(std::bind(SIMIX_vm_get_pm, vm)); + return simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_get_pm, vm)); } void simcall_vm_set_bound(sg_host_t vm, double bound) { - simgrid::simix::kernel(std::bind(SIMIX_vm_set_bound, vm, bound)); + simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_set_bound, vm, bound)); } void simcall_vm_set_affinity(sg_host_t vm, sg_host_t pm, unsigned long mask) { - simgrid::simix::kernel(std::bind(SIMIX_vm_set_affinity, vm, pm, mask)); + simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_set_affinity, vm, pm, mask)); } /** @@ -260,7 +263,7 @@ void simcall_vm_set_affinity(sg_host_t vm, sg_host_t pm, unsigned long mask) */ void simcall_vm_migrate(sg_host_t vm, sg_host_t host) { - return simgrid::simix::kernel(std::bind(SIMIX_vm_migrate, vm, host)); + simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_migrate, vm, host)); } /** @@ -326,7 +329,7 @@ void simcall_vm_shutdown(sg_host_t vm) */ void simcall_vm_destroy(sg_host_t vm) { - simgrid::simix::kernel(std::bind(SIMIX_vm_destroy, vm)); + simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_destroy, vm)); } /** @@ -345,48 +348,10 @@ void simcall_vm_destroy(sg_host_t vm) */ void simcall_vm_migratefrom_resumeto(sg_host_t vm, sg_host_t src_pm, sg_host_t dst_pm) { - simgrid::simix::kernel(std::bind( + simgrid::simix::kernelImmediate(std::bind( SIMIX_vm_migratefrom_resumeto, vm, src_pm, dst_pm)); } -/** - * \ingroup simix_process_management - * \brief Creates and runs a new SIMIX process. - * - * The structure and the corresponding thread are created and put in the list of ready processes. - * - * \param name a name for the process. It is for user-level information and can be NULL. - * \param code the main function of the process - * \param data a pointer to any data one may want to attach to the new object. It is for user-level information and can be NULL. - * It can be retrieved with the function \ref simcall_process_get_data. - * \param hostname name of the host where the new agent is executed. - * \param kill_time time when the process is killed - * \param argc first argument passed to \a code - * \param argv second argument passed to \a code - * \param properties the properties of the process - * \param auto_restart either it is autorestarting or not. - */ -smx_process_t simcall_process_create(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) -{ - if (name == nullptr) - name = ""; - auto wrapped_code = simgrid::simix::wrap_main(code, argc, argv); - for (int i = 0; i != argc; ++i) - xbt_free(argv[i]); - xbt_free(argv); - smx_process_t res = simcall_process_create(name, - std::move(wrapped_code), - data, hostname, kill_time, properties, auto_restart); - return res; -} - /** * \ingroup simix_process_management * \brief Kills a SIMIX process. @@ -476,29 +441,7 @@ void simcall_process_resume(smx_process_t process) */ int simcall_process_count(void) { - return simgrid::simix::kernel(SIMIX_process_count); -} - -/** - * \ingroup simix_process_management - * \brief Return the PID of a #smx_process_t. - * \param process a SIMIX process - * \return the PID of this process - */ -int simcall_process_get_PID(smx_process_t process) -{ - return SIMIX_process_get_PID(process); -} - -/** - * \ingroup simix_process_management - * \brief Return the parent PID of a #smx_process_t. - * \param process a SIMIX process - * \return the PID of this process parenrt - */ -int simcall_process_get_PPID(smx_process_t process) -{ - return SIMIX_process_get_PPID(process); + return simgrid::simix::kernelImmediate(SIMIX_process_count); } /** @@ -522,7 +465,7 @@ void* simcall_process_get_data(smx_process_t process) */ void simcall_process_set_data(smx_process_t process, void *data) { - simgrid::simix::kernel(std::bind(SIMIX_process_set_data, process, data)); + simgrid::simix::kernelImmediate(std::bind(SIMIX_process_set_data, process, data)); } /** @@ -538,7 +481,7 @@ void simcall_process_set_kill_time(smx_process_t process, double kill_time) kill_time, process->name.c_str(), sg_host_get_name(process->host)); process->kill_timer = SIMIX_timer_set(kill_time, [=] { simix_global->kill_process_function(process); - process->kill_timer=NULL; + process->kill_timer=nullptr; }); } /** @@ -549,33 +492,6 @@ double simcall_process_get_kill_time(smx_process_t process) { return SIMIX_timer_get_date(process->kill_timer); } -/** - * \ingroup simix_process_management - * \brief Return the location on which an agent is running. - * - * This functions returns the sg_host_t corresponding to the location on which - * \a process is running. - * \param process SIMIX process - * \return SIMIX host - */ -sg_host_t simcall_process_get_host(smx_process_t process) -{ - return SIMIX_process_get_host(process); -} - -/** - * \ingroup simix_process_management - * \brief Return the name of an agent. - * - * This functions checks whether \a process is a valid pointer or not and return its name. - * \param process SIMIX process - * \return The process name - */ -const char* simcall_process_get_name(smx_process_t process) -{ - return SIMIX_process_get_name(process); -} - /** * \ingroup simix_process_management * \brief Returns true if the process is suspended . @@ -656,31 +572,6 @@ smx_mailbox_t simcall_mbox_create(const char *name) return simcall_BODY_mbox_create(name); } -/** - * \ingroup simix_mbox_management - * \brief Returns a rendez-vous point knowing its name - */ -smx_mailbox_t simcall_mbox_get_by_name(const char *name) -{ - /* FIXME: this is a horrible loss of performance, so we hack it out by - * skipping the simcall (for now). It works in parallel, it won't work on - * distributed but probably we will change MSG for that. */ - - return SIMIX_mbox_get_by_name(name); -} - -/** - * \ingroup simix_mbox_management - * \brief returns the communication at the head of the rendez-vous - * \param mbox The rendez-vous point - * \return The communication or NULL if empty - */ -smx_synchro_t simcall_mbox_front(smx_mailbox_t mbox) -{ - - return mbox->comm_queue->empty()? nullptr:mbox->comm_queue->front(); -} - void simcall_mbox_set_receiver(smx_mailbox_t mbox, smx_process_t process) { simcall_BODY_mbox_set_receiver(mbox, process); @@ -704,11 +595,11 @@ void simcall_comm_send(smx_process_t sender, smx_mailbox_t mbox, double task_siz if (MC_is_active() || MC_record_replay_is_active()) { /* the model-checker wants two separate simcalls */ - smx_synchro_t comm = NULL; /* MC needs the comm to be set to NULL during the simcall */ + smx_synchro_t comm = nullptr; /* MC needs the comm to be set to nullptr during the simcall */ comm = simcall_comm_isend(sender, mbox, task_size, rate, - src_buff, src_buff_size, match_fun, NULL, copy_data_fun, data, 0); + src_buff, src_buff_size, match_fun, nullptr, copy_data_fun, data, 0); simcall_comm_wait(comm, timeout); - comm = NULL; + comm = nullptr; } else { simcall_BODY_comm_send(sender, mbox, task_size, rate, src_buff, src_buff_size, @@ -751,11 +642,11 @@ void simcall_comm_recv(smx_process_t receiver, smx_mailbox_t mbox, void *dst_buf if (MC_is_active() || MC_record_replay_is_active()) { /* the model-checker wants two separate simcalls */ - smx_synchro_t comm = NULL; /* MC needs the comm to be set to NULL during the simcall */ + smx_synchro_t comm = nullptr; /* MC needs the comm to be set to nullptr during the simcall */ comm = simcall_comm_irecv(receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate); simcall_comm_wait(comm, timeout); - comm = NULL; + comm = nullptr; } else { simcall_BODY_comm_recv(receiver, mbox, dst_buff, dst_buff_size, @@ -792,8 +683,8 @@ smx_synchro_t simcall_comm_iprobe(smx_mailbox_t mbox, int type, int src, int tag */ void simcall_comm_cancel(smx_synchro_t synchro) { - simgrid::simix::kernel([synchro]{ - simgrid::simix::Comm *comm = static_cast(synchro); + simgrid::simix::kernelImmediate([synchro]{ + simgrid::kernel::activity::Comm *comm = static_cast(synchro); comm->cancel(); }); } @@ -801,19 +692,19 @@ void simcall_comm_cancel(smx_synchro_t synchro) /** * \ingroup simix_comm_management */ -unsigned int simcall_comm_waitany(xbt_dynar_t comms) +unsigned int simcall_comm_waitany(xbt_dynar_t comms, double timeout) { - return simcall_BODY_comm_waitany(comms); + return simcall_BODY_comm_waitany(comms, timeout); } /** * \ingroup simix_comm_management */ -int simcall_comm_testany(xbt_dynar_t comms) +int simcall_comm_testany(smx_synchro_t* comms, size_t count) { - if (xbt_dynar_is_empty(comms)) + if (count == 0) return -1; - return simcall_BODY_comm_testany(comms); + return simcall_BODY_comm_testany(comms, count); } /** @@ -834,7 +725,7 @@ void simcall_comm_wait(smx_synchro_t comm, double timeout) */ void simcall_set_category(smx_synchro_t synchro, const char *category) { - if (category == NULL) { + if (category == nullptr) { return; } simcall_BODY_set_category(synchro, category); @@ -1126,7 +1017,12 @@ xbt_dict_t simcall_storage_get_content(smx_storage_t storage) void simcall_run_kernel(std::function const& code) { - return simcall_BODY_run_kernel((void*) &code); + simcall_BODY_run_kernel(&code); +} + +void simcall_run_blocking(std::function const& code) +{ + simcall_BODY_run_blocking(&code); } int simcall_mc_random(int min, int max) { @@ -1139,3 +1035,15 @@ int simcall_mc_random(int min, int max) { const char *SIMIX_simcall_name(e_smx_simcall_t kind) { return simcall_names[kind]; } + +namespace simgrid { +namespace simix { + +void unblock(smx_process_t process) +{ + xbt_assert(SIMIX_is_maestro()); + SIMIX_simcall_answer(&process->simcall); +} + +} +}