X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/3b90b3b5c4a746383ae521e3d2ea8fc931db47cc..ea8f841a468a3db03f1d74e8e92e2dfba3db6f3b:/src/simix/libsmx.c diff --git a/src/simix/libsmx.c b/src/simix/libsmx.c index 6287ac4c4d..ab101d1db2 100644 --- a/src/simix/libsmx.c +++ b/src/simix/libsmx.c @@ -5,14 +5,15 @@ /* */ /* This is somehow the "libc" of SimGrid */ -/* Copyright (c) 2010-2014. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2010-2015. The SimGrid Team. + * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it - * under the terms of the license (GNU LGPL) which comes with this package. */ + * under the terms of the license (GNU LGPL) which comes with this package. */ -#include "mc/mc_replay.h" +#include "src/mc/mc_replay.h" #include "smx_private.h" -#include "mc/mc_forward.h" +#include "src/mc/mc_forward.h" #include "xbt/ex.h" #include /* isfinite() */ #include "mc/mc.h" @@ -21,18 +22,6 @@ XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix); #include "popping_bodies.c" -/** - * \ingroup simix_host_management - * \brief Returns the name of a host. - * - * \param host A SIMIX host - * \return The name of this host - */ -const char* simcall_host_get_name(sg_host_t host) -{ - return simcall_BODY_host_get_name(host); -} - /** * \ingroup simix_host_management * \brief Start the host if it is off @@ -79,32 +68,6 @@ xbt_dict_t simcall_asr_get_properties(const char *name) return simcall_BODY_asr_get_properties(name); } - -/** - * \ingroup simix_host_management - * \brief Returns the speed of the processor. - * - * The speed returned does not take into account the current load on the machine. - * \param host A SIMIX host - * \return The speed of this host (in Mflop/s) - */ -double simcall_host_get_speed(sg_host_t host) -{ - return simcall_BODY_host_get_speed(host); -} - -/** - * \ingroup simix_host_management - * \brief Returns the number of core of the processor. - * - * \param host A SIMIX host - * \return The number of core - */ -int simcall_host_get_core(sg_host_t host) -{ - return simcall_BODY_host_get_core(host); -} - /** * \ingroup simix_host_management * \brief Returns the list of processes attached to the host. @@ -117,31 +80,6 @@ xbt_swag_t simcall_host_get_process_list(sg_host_t host) return simcall_BODY_host_get_process_list(host); } - -/** - * \ingroup simix_host_management - * \brief Returns the available speed of the processor. - * - * \return Speed currently available (in Mflop/s) - */ -double simcall_host_get_available_speed(sg_host_t host) -{ - return simcall_BODY_host_get_available_speed(host); -} - -/** - * \ingroup simix_host_management - * \brief Returns the state of a host. - * - * Two states are possible: 1 if the host is active or 0 if it has crashed. - * \param host A SIMIX host - * \return 1 if the host is available, 0 otherwise - */ -int simcall_host_get_state(sg_host_t host) -{ - return simcall_BODY_host_get_state(host); -} - /** * \ingroup simix_host_management * \brief Returns the power peak of a host. @@ -167,18 +105,6 @@ double simcall_host_get_power_peak_at(sg_host_t host, int pstate_index) return simcall_BODY_host_get_power_peak_at(host, pstate_index); } -/** - * \ingroup simix_host_management - * \brief Returns the number of power states for a host. - * - * \param host A SIMIX host - * \return the number of power states - */ -int simcall_host_get_nb_pstates(sg_host_t host) -{ - return simcall_BODY_host_get_nb_pstates(host); -} - /** * \ingroup simix_host_management * \brief Sets the pstate at which the host should run @@ -190,28 +116,7 @@ void simcall_host_set_pstate(sg_host_t host, int pstate_index) { simcall_BODY_host_set_pstate(host, pstate_index); } -/** - * \ingroup simix_host_management - * \brief Gets the pstate at which that host currently runs. - * - * \param host A SIMIX host - */ -int simcall_host_get_pstate(sg_host_t host) -{ - return simcall_BODY_host_get_pstate(host); -} -/** - * \ingroup simix_host_management - * \brief Returns the total energy consumed by the host (in Joules) - * - * \param host A SIMIX host - * \return the energy consumed by the host (double) - */ -double simcall_host_get_consumed_energy(sg_host_t host) -{ - return simcall_BODY_host_get_consumed_energy(host); -} /** \ingroup simix_host_management * \brief Returns the amount of watt dissipated at the given pstate when the host is idling */ @@ -228,21 +133,20 @@ double simcall_host_get_wattmax_at(msg_host_t host, int pstate){ /** - * \ingroup simix_host_management + * \ingroup simix_process_management * \brief Creates a synchro that executes some computation of an host. * * This function creates a SURF action and allocates the data necessary * to create the SIMIX synchro. It can raise a host_error exception if the host crashed. * * \param name Name of the execution synchro to create - * \param host SIMIX host where the synchro will be executed * \param flops_amount amount Computation amount (in flops) * \param priority computation priority * \param bound * \param affinity_mask * \return A new SIMIX execution synchronization */ -smx_synchro_t simcall_host_execute(const char *name, sg_host_t host, +smx_synchro_t simcall_process_execute(const char *name, double flops_amount, double priority, double bound, unsigned long affinity_mask) { @@ -250,11 +154,11 @@ smx_synchro_t simcall_host_execute(const char *name, sg_host_t host, xbt_assert(isfinite(flops_amount), "flops_amount is not finite!"); xbt_assert(isfinite(priority), "priority is not finite!"); - return simcall_BODY_host_execute(name, host, flops_amount, priority, bound, affinity_mask); + return simcall_BODY_process_execute(name, flops_amount, priority, bound, affinity_mask); } /** - * \ingroup simix_host_management + * \ingroup simix_process_management * \brief Creates a synchro that may involve parallel computation on * several hosts and communication between them. * @@ -268,7 +172,7 @@ smx_synchro_t simcall_host_execute(const char *name, sg_host_t host, * \param rate the SURF action rate * \return A new SIMIX execution synchronization */ -smx_synchro_t simcall_host_parallel_execute(const char *name, +smx_synchro_t simcall_process_parallel_execute(const char *name, int host_nb, sg_host_t *host_list, double *flops_amount, @@ -289,7 +193,7 @@ smx_synchro_t simcall_host_parallel_execute(const char *name, xbt_assert(isfinite(amount), "amount is not finite!"); xbt_assert(isfinite(rate), "rate is not finite!"); - return simcall_BODY_host_parallel_execute(name, host_nb, host_list, + return simcall_BODY_process_parallel_execute(name, host_nb, host_list, flops_amount, bytes_amount, amount, rate); @@ -297,84 +201,84 @@ smx_synchro_t simcall_host_parallel_execute(const char *name, } /** - * \ingroup simix_host_management + * \ingroup simix_process_management * \brief Destroys an execution synchro. * * Destroys a synchro, freeing its memory. This function cannot be called if there are a conditional waiting for it. * \param execution The execution synchro to destroy */ -void simcall_host_execution_destroy(smx_synchro_t execution) +void simcall_process_execution_destroy(smx_synchro_t execution) { - simcall_BODY_host_execution_destroy(execution); + simcall_BODY_process_execution_destroy(execution); } /** - * \ingroup simix_host_management + * \ingroup simix_process_management * \brief Cancels an execution synchro. * * This functions stops the execution. It calls a surf function. * \param execution The execution synchro to cancel */ -void simcall_host_execution_cancel(smx_synchro_t execution) +void simcall_process_execution_cancel(smx_synchro_t execution) { - simcall_BODY_host_execution_cancel(execution); + simcall_BODY_process_execution_cancel(execution); } /** - * \ingroup simix_host_management + * \ingroup simix_process_management * \brief Returns how much of an execution synchro remains to be done. * * \param execution The execution synchro * \return The remaining amount */ -double simcall_host_execution_get_remains(smx_synchro_t execution) +double simcall_process_execution_get_remains(smx_synchro_t execution) { - return simcall_BODY_host_execution_get_remains(execution); + return simcall_BODY_process_execution_get_remains(execution); } /** - * \ingroup simix_host_management + * \ingroup simix_process_management * \brief Returns the state of an execution synchro. * * \param execution The execution synchro * \return The state */ -e_smx_state_t simcall_host_execution_get_state(smx_synchro_t execution) +e_smx_state_t simcall_process_execution_get_state(smx_synchro_t execution) { - return simcall_BODY_host_execution_get_state(execution); + return simcall_BODY_process_execution_get_state(execution); } /** - * \ingroup simix_host_management + * \ingroup simix_process_management * \brief Changes the priority of an execution synchro. * * This functions changes the priority only. It calls a surf function. * \param execution The execution synchro * \param priority The new priority */ -void simcall_host_execution_set_priority(smx_synchro_t execution, double priority) +void simcall_process_execution_set_priority(smx_synchro_t execution, double priority) { /* checking for infinite values */ xbt_assert(isfinite(priority), "priority is not finite!"); - simcall_BODY_host_execution_set_priority(execution, priority); + simcall_BODY_process_execution_set_priority(execution, priority); } /** - * \ingroup simix_host_management + * \ingroup simix_process_management * \brief Changes the capping (the maximum CPU utilization) of an execution synchro. * * This functions changes the capping only. It calls a surf function. * \param execution The execution synchro * \param bound The new bound */ -void simcall_host_execution_set_bound(smx_synchro_t execution, double bound) +void simcall_process_execution_set_bound(smx_synchro_t execution, double bound) { - simcall_BODY_host_execution_set_bound(execution, bound); + simcall_BODY_process_execution_set_bound(execution, bound); } /** - * \ingroup simix_host_management + * \ingroup simix_process_management * \brief Changes the CPU affinity of an execution synchro. * * This functions changes the CPU affinity of an execution synchro. See taskset(1) on Linux. @@ -382,9 +286,9 @@ void simcall_host_execution_set_bound(smx_synchro_t execution, double bound) * \param host Host * \param mask Affinity mask */ -void simcall_host_execution_set_affinity(smx_synchro_t execution, sg_host_t host, unsigned long mask) +void simcall_process_execution_set_affinity(smx_synchro_t execution, sg_host_t host, unsigned long mask) { - simcall_BODY_host_execution_set_affinity(execution, host, mask); + simcall_BODY_process_execution_set_affinity(execution, host, mask); } /** @@ -393,9 +297,9 @@ void simcall_host_execution_set_affinity(smx_synchro_t execution, sg_host_t host * * \param execution The execution synchro */ -e_smx_state_t simcall_host_execution_wait(smx_synchro_t execution) +e_smx_state_t simcall_process_execution_wait(smx_synchro_t execution) { - return simcall_BODY_host_execution_wait(execution); + return simcall_BODY_process_execution_wait(execution); } @@ -570,7 +474,6 @@ void simcall_vm_migratefrom_resumeto(sg_host_t vm, sg_host_t src_pm, sg_host_t d * * The structure and the corresponding thread are created and put in the list of ready processes. * - * \param process the process created will be stored in this pointer * \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. @@ -637,9 +540,9 @@ void simcall_process_cleanup(smx_process_t process) * \param process the process to migrate * \param dest name of the new host */ -void simcall_process_change_host(smx_process_t process, sg_host_t dest) +void simcall_process_set_host(smx_process_t process, sg_host_t dest) { - simcall_BODY_process_change_host(process, dest); + simcall_BODY_process_set_host(process, dest); } void simcall_process_join(smx_process_t process, double timeout) @@ -758,8 +661,6 @@ void simcall_process_set_data(smx_process_t process, void *data) /** * \ingroup simix_process_management * \brief Set the kill time of a process. - * \param process a process - * \param kill_time a double */ void simcall_process_set_kill_time(smx_process_t process, double kill_time) { @@ -772,6 +673,13 @@ void simcall_process_set_kill_time(smx_process_t process, double kill_time) } } } +/** + * \ingroup simix_process_management + * \brief Get the kill time of a process (or 0 if unset). + */ +double simcall_process_get_kill_time(smx_process_t process) { + return SIMIX_timer_get_date(process->kill_timer); +} /** * \ingroup simix_process_management @@ -946,7 +854,7 @@ smx_process_t simcall_rdv_get_receiver(smx_rdv_t rdv) /** * \ingroup simix_comm_management */ -void simcall_comm_send(smx_process_t src, smx_rdv_t rdv, double task_size, double rate, +void simcall_comm_send(smx_process_t sender, smx_rdv_t rdv, double task_size, double rate, void *src_buff, size_t src_buff_size, int (*match_fun)(void *, void *, smx_synchro_t), void (*copy_data_fun)(smx_synchro_t, void*, size_t), void *data, @@ -962,13 +870,13 @@ void simcall_comm_send(smx_process_t src, smx_rdv_t rdv, double task_size, doubl 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 */ - comm = simcall_comm_isend(src, rdv, task_size, rate, + comm = simcall_comm_isend(sender, rdv, task_size, rate, src_buff, src_buff_size, match_fun, NULL, copy_data_fun, data, 0); simcall_comm_wait(comm, timeout); comm = NULL; } else { - simcall_BODY_comm_send(src, rdv, task_size, rate, src_buff, src_buff_size, + simcall_BODY_comm_send(sender, rdv, task_size, rate, src_buff, src_buff_size, match_fun, copy_data_fun, data, timeout); } } @@ -976,7 +884,7 @@ void simcall_comm_send(smx_process_t src, smx_rdv_t rdv, double task_size, doubl /** * \ingroup simix_comm_management */ -smx_synchro_t simcall_comm_isend(smx_process_t src, smx_rdv_t rdv, double task_size, double rate, +smx_synchro_t simcall_comm_isend(smx_process_t sender, smx_rdv_t rdv, double task_size, double rate, void *src_buff, size_t src_buff_size, int (*match_fun)(void *, void *, smx_synchro_t), void (*clean_fun)(void *), @@ -990,7 +898,7 @@ smx_synchro_t simcall_comm_isend(smx_process_t src, smx_rdv_t rdv, double task_s xbt_assert(rdv, "No rendez-vous point defined for isend"); - return simcall_BODY_comm_isend(src, rdv, task_size, rate, src_buff, + return simcall_BODY_comm_isend(sender, rdv, task_size, rate, src_buff, src_buff_size, match_fun, clean_fun, copy_data_fun, data, detached); } @@ -998,7 +906,7 @@ smx_synchro_t simcall_comm_isend(smx_process_t src, smx_rdv_t rdv, double task_s /** * \ingroup simix_comm_management */ -void simcall_comm_recv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size, +void simcall_comm_recv(smx_process_t receiver, smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size, int (*match_fun)(void *, void *, smx_synchro_t), void (*copy_data_fun)(smx_synchro_t, void*, size_t), void *data, double timeout, double rate) @@ -1009,27 +917,27 @@ void simcall_comm_recv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size, 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 */ - comm = simcall_comm_irecv(rdv, dst_buff, dst_buff_size, + comm = simcall_comm_irecv(receiver, rdv, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate); simcall_comm_wait(comm, timeout); comm = NULL; } else { - simcall_BODY_comm_recv(rdv, dst_buff, dst_buff_size, + simcall_BODY_comm_recv(receiver, rdv, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, timeout, rate); } } /** * \ingroup simix_comm_management */ -smx_synchro_t simcall_comm_irecv(smx_rdv_t rdv, void *dst_buff, size_t *dst_buff_size, +smx_synchro_t simcall_comm_irecv(smx_process_t receiver, smx_rdv_t rdv, void *dst_buff, size_t *dst_buff_size, int (*match_fun)(void *, void *, smx_synchro_t), void (*copy_data_fun)(smx_synchro_t, void*, size_t), void *data, double rate) { xbt_assert(rdv, "No rendez-vous point defined for irecv"); - return simcall_BODY_comm_irecv(rdv, dst_buff, dst_buff_size, + return simcall_BODY_comm_irecv(receiver, rdv, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate); }