X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/ccd47bd5695175720f504772d3b2dfd517075639..1a89ab3887d98bf7298d20b506ff989c2f02b850:/src/simix/smx_user.c diff --git a/src/simix/smx_user.c b/src/simix/smx_user.c index 78460582f9..243adf3082 100644 --- a/src/simix/smx_user.c +++ b/src/simix/smx_user.c @@ -1,6 +1,24 @@ +/* smx_user.c - public interface to simix */ + +/* Copyright (c) 2010, 2011. Da 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. */ +#ifndef _SVID_SOURCE +# define _SVID_SOURCE /* strdup() */ +#endif +#ifndef _ISOC99_SOURCE +# define _ISOC99_SOURCE /* isfinite() */ +#endif +#ifndef _ISO_C99_SOURCE +# define _ISO_C99_SOURCE /* isfinite() */ +#endif +#include /* isfinite() */ + #include "private.h" #include "mc/mc.h" + XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix); static const char* request_names[] = { @@ -154,6 +172,10 @@ smx_action_t SIMIX_req_host_execute(const char *name, smx_host_t host, double computation_amount, double priority) { + /* checking for infinite values */ + xbt_assert(isfinite(computation_amount), "computation_amount is not finite!"); + xbt_assert(isfinite(priority), "priority is not finite!"); + smx_req_t req = SIMIX_req_mine(); req->call = REQ_HOST_EXECUTE; @@ -186,6 +208,19 @@ smx_action_t SIMIX_req_host_parallel_execute(const char *name, double amount, double rate) { + int i,j; + /* checking for infinite values */ + for (i = 0 ; i < host_nb ; ++i) { + xbt_assert(isfinite(computation_amount[i]), "computation_amount[%d] is not finite!", i); + for (j = 0 ; j < host_nb ; ++j) { + xbt_assert(isfinite(communication_amount[i + host_nb * j]), + "communication_amount[%d+%d*%d] is not finite!", i, host_nb, j); + } + } + + xbt_assert(isfinite(amount), "amount is not finite!"); + xbt_assert(isfinite(rate), "rate is not finite!"); + smx_req_t req = SIMIX_req_mine(); req->call = REQ_HOST_PARALLEL_EXECUTE; @@ -271,6 +306,9 @@ e_smx_state_t SIMIX_req_host_execution_get_state(smx_action_t execution) */ void SIMIX_req_host_execution_set_priority(smx_action_t execution, double priority) { + /* checking for infinite values */ + xbt_assert(isfinite(priority), "priority is not finite!"); + smx_req_t req = SIMIX_req_mine(); req->call = REQ_HOST_EXECUTION_SET_PRIORITY; @@ -345,8 +383,18 @@ void SIMIX_req_process_kill(smx_process_t process) SIMIX_request_push(); } +/** \brief Kills all SIMIX processes. + */ +void SIMIX_req_process_killall(void) +{ + smx_req_t req = SIMIX_req_mine(); + + req->call = REQ_PROCESS_KILLALL; + SIMIX_request_push(); +} + /** \brief Cleans up a SIMIX process. - * \param process poor victim + * \param process poor victim (must have already been killed) */ void SIMIX_req_process_cleanup(smx_process_t process) { @@ -366,13 +414,12 @@ void SIMIX_req_process_cleanup(smx_process_t process) * \param source name of the previous host * \param dest name of the new host */ -void SIMIX_req_process_change_host(smx_process_t process, const char *source, const char *dest) +void SIMIX_req_process_change_host(smx_process_t process, smx_host_t dest) { smx_req_t req = SIMIX_req_mine(); req->call = REQ_PROCESS_CHANGE_HOST; req->process_change_host.process = process; - req->process_change_host.source = source; req->process_change_host.dest = dest; SIMIX_request_push(); } @@ -387,7 +434,7 @@ void SIMIX_req_process_change_host(smx_process_t process, const char *source, co */ void SIMIX_req_process_suspend(smx_process_t process) { - xbt_assert0(process, "Invalid parameters"); + xbt_assert(process, "Invalid parameters"); smx_req_t req = SIMIX_req_mine(); @@ -436,6 +483,11 @@ int SIMIX_req_process_count(void) */ void* SIMIX_req_process_get_data(smx_process_t process) { + if (process == SIMIX_process_self()) { + /* avoid a request if this function is called by the process itself */ + return SIMIX_process_self_get_data(); + } + smx_req_t req = SIMIX_req_mine(); req->call = REQ_PROCESS_GET_DATA; @@ -453,12 +505,19 @@ void* SIMIX_req_process_get_data(smx_process_t process) */ void SIMIX_req_process_set_data(smx_process_t process, void *data) { - smx_req_t req = SIMIX_req_mine(); + if (process == SIMIX_process_self()) { + /* avoid a request if this function is called by the process itself */ + SIMIX_process_self_set_data(data); + } + else { - req->call = REQ_PROCESS_SET_DATA; - req->process_set_data.process = process; - req->process_set_data.data = data; - SIMIX_request_push(); + smx_req_t req = SIMIX_req_mine(); + + req->call = REQ_PROCESS_SET_DATA; + req->process_set_data.process = process; + req->process_set_data.data = data; + SIMIX_request_push(); + } } /** @@ -487,6 +546,11 @@ smx_host_t SIMIX_req_process_get_host(smx_process_t process) */ const char* SIMIX_req_process_get_name(smx_process_t process) { + if (process == SIMIX_process_self()) { + /* avoid a request if this function is called by the process itself */ + return process->name; + } + smx_req_t req = SIMIX_req_mine(); req->call = REQ_PROCESS_GET_NAME; @@ -538,6 +602,9 @@ xbt_dict_t SIMIX_req_process_get_properties(smx_process_t process) */ e_smx_state_t SIMIX_req_process_sleep(double duration) { + /* checking for infinite values */ + xbt_assert(isfinite(duration), "duration is not finite!"); + smx_req_t req = SIMIX_req_mine(); req->call = REQ_PROCESS_SLEEP; @@ -579,7 +646,7 @@ void SIMIX_req_rdv_destroy(smx_rdv_t rdv) smx_rdv_t SIMIX_req_rdv_get_by_name(const char *name) { - xbt_assert0(name != NULL, "Invalid parameter for SIMIX_req_rdv_get_by_name (name is NULL)"); + xbt_assert(name != NULL, "Invalid parameter for SIMIX_req_rdv_get_by_name (name is NULL)"); /* FIXME: this is a horrible lost of performance, so we hack it out by * skipping the request (for now). It won't work on distributed but @@ -634,7 +701,12 @@ void SIMIX_req_comm_send(smx_rdv_t rdv, double task_size, double rate, int (*match_fun)(void *, void *), void *data, double timeout) { - xbt_assert0(rdv, "No rendez-vous point defined for send"); + /* checking for infinite values */ + xbt_assert(isfinite(task_size), "task_size is not finite!"); + xbt_assert(isfinite(rate), "rate is not finite!"); + xbt_assert(isfinite(timeout), "timeout is not finite!"); + + xbt_assert(rdv, "No rendez-vous point defined for send"); if (MC_IS_ENABLED) { /* the model-checker wants two separate requests */ @@ -664,7 +736,11 @@ smx_action_t SIMIX_req_comm_isend(smx_rdv_t rdv, double task_size, double rate, int (*match_fun)(void *, void *), void *data, int detached) { - xbt_assert0(rdv, "No rendez-vous point defined for isend"); + /* checking for infinite values */ + xbt_assert(isfinite(task_size), "task_size is not finite!"); + xbt_assert(isfinite(rate), "rate is not finite!"); + + xbt_assert(rdv, "No rendez-vous point defined for isend"); smx_req_t req = SIMIX_req_mine(); @@ -685,7 +761,8 @@ smx_action_t SIMIX_req_comm_isend(smx_rdv_t rdv, double task_size, double rate, void SIMIX_req_comm_recv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size, int (*match_fun)(void *, void *), void *data, double timeout) { - xbt_assert0(rdv, "No rendez-vous point defined for recv"); + xbt_assert(isfinite(timeout), "timeout is not finite!"); + xbt_assert(rdv, "No rendez-vous point defined for recv"); if (MC_IS_ENABLED) { /* the model-checker wants two separate requests */ @@ -711,7 +788,7 @@ void SIMIX_req_comm_recv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size, smx_action_t SIMIX_req_comm_irecv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size, int (*match_fun)(void *, void *), void *data) { - xbt_assert0(rdv, "No rendez-vous point defined for irecv"); + xbt_assert(rdv, "No rendez-vous point defined for irecv"); smx_req_t req = SIMIX_req_mine(); @@ -728,7 +805,7 @@ smx_action_t SIMIX_req_comm_irecv(smx_rdv_t rdv, void *dst_buff, size_t * dst_bu void SIMIX_req_comm_destroy(smx_action_t comm) { - xbt_assert0(comm, "Invalid parameter"); + xbt_assert(comm, "Invalid parameter"); /* FIXME remove this request type: comms are auto-destroyed now, * but what happens with unfinished comms? */ @@ -779,6 +856,8 @@ int SIMIX_req_comm_testany(xbt_dynar_t comms) void SIMIX_req_comm_wait(smx_action_t comm, double timeout) { + xbt_assert(isfinite(timeout), "timeout is not finite!"); + smx_req_t req = SIMIX_req_mine(); req->call = REQ_COMM_WAIT; @@ -999,6 +1078,8 @@ void SIMIX_req_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) { + xbt_assert(isfinite(timeout), "timeout is not finite!"); + smx_req_t req = SIMIX_req_mine(); req->call = REQ_COND_WAIT_TIMEOUT; @@ -1074,6 +1155,8 @@ void SIMIX_req_sem_acquire(smx_sem_t sem) void SIMIX_req_sem_acquire_timeout(smx_sem_t sem, double timeout) { + xbt_assert(isfinite(timeout), "timeout is not finite!"); + smx_req_t req = SIMIX_req_mine(); req->call = REQ_SEM_ACQUIRE_TIMEOUT;