From 48d16e98696450e0dc1ae85cfb8f84b41d15b409 Mon Sep 17 00:00:00 2001 From: Frederic Suter Date: Wed, 6 Mar 2019 11:57:40 +0100 Subject: [PATCH] Objectify MSG task send --- src/msg/msg_gos.cpp | 101 -------------------------------------- src/msg/msg_private.hpp | 3 +- src/msg/msg_task.cpp | 106 +++++++++++++++++++++++++++++++++++++++- 3 files changed, 107 insertions(+), 103 deletions(-) diff --git a/src/msg/msg_gos.cpp b/src/msg/msg_gos.cpp index 1eba2f67f6..88a6c3af0e 100644 --- a/src/msg/msg_gos.cpp +++ b/src/msg/msg_gos.cpp @@ -458,107 +458,6 @@ void MSG_comm_copy_data_from_SIMIX(simgrid::kernel::activity::CommImpl* comm, vo } } -/** - * @brief Sends a task to a mailbox - * - * This is a blocking function, the execution flow will be blocked until the task is sent (and received on the other - * side if #MSG_task_receive is used). - * See #MSG_task_isend for sending tasks asynchronously. - * - * @param task the task to be sent - * @param alias the mailbox name to where the task is sent - * - * @return Returns #MSG_OK if the task was successfully sent, - * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE otherwise. - */ -msg_error_t MSG_task_send(msg_task_t task, const char *alias) -{ - XBT_DEBUG("MSG_task_send: Trying to send a message on mailbox '%s'", alias); - return MSG_task_send_with_timeout(task, alias, -1); -} - -/** - * @brief Sends a task to a mailbox with a maximum rate - * - * This is a blocking function, the execution flow will be blocked until the task is sent. The maxrate parameter allows - * the application to limit the bandwidth utilization of network links when sending the task. - * - * The maxrate parameter can be used to send a task with a limited bandwidth (smaller than the physical available - * value). Use MSG_task_send() if you don't limit the rate (or pass -1 as a rate value do disable this feature). - * - * @param task the task to be sent - * @param alias the mailbox name to where the task is sent - * @param maxrate the maximum communication rate for sending this task (byte/sec) - * - * @return Returns #MSG_OK if the task was successfully sent, - * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE otherwise. - */ -msg_error_t MSG_task_send_bounded(msg_task_t task, const char *alias, double maxrate) -{ - task->set_rate(maxrate); - return MSG_task_send(task, alias); -} - -/** - * @brief Sends a task to a mailbox with a timeout - * - * This is a blocking function, the execution flow will be blocked until the task is sent or the timeout is achieved. - * - * @param task the task to be sent - * @param alias the mailbox name to where the task is sent - * @param timeout is the maximum wait time for completion (if -1, this call is the same as #MSG_task_send) - * - * @return Returns #MSG_OK if the task was successfully sent, - * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE, or #MSG_TIMEOUT otherwise. - */ -msg_error_t MSG_task_send_with_timeout(msg_task_t task, const char *alias, double timeout) -{ - msg_error_t ret = MSG_OK; - /* Try to send it */ - try { - simgrid::s4u::CommPtr comm = task->send_async(alias, nullptr, false); - task->comm = comm; - comm->wait_for(timeout); - } catch (simgrid::TimeoutError& e) { - ret = MSG_TIMEOUT; - } catch (simgrid::CancelException& e) { - ret = MSG_HOST_FAILURE; - } catch (xbt_ex& e) { - if (e.category == network_error) - ret = MSG_TRANSFER_FAILURE; - else - throw; - - /* If the send failed, it is not used anymore */ - task->set_not_used(); - } - - return ret; -} - -/** - * @brief Sends a task to a mailbox with a timeout and with a maximum rate - * - * This is a blocking function, the execution flow will be blocked until the task is sent or the timeout is achieved. - * - * The maxrate parameter can be used to send a task with a limited bandwidth (smaller than the physical available - * value). Use MSG_task_send_with_timeout() if you don't limit the rate (or pass -1 as a rate value do disable this - * feature). - * - * @param task the task to be sent - * @param alias the mailbox name to where the task is sent - * @param timeout is the maximum wait time for completion (if -1, this call is the same as #MSG_task_send) - * @param maxrate the maximum communication rate for sending this task (byte/sec) - * - * @return Returns #MSG_OK if the task was successfully sent, - * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE, or #MSG_TIMEOUT otherwise. - */ -msg_error_t MSG_task_send_with_timeout_bounded(msg_task_t task, const char *alias, double timeout, double maxrate) -{ - task->set_rate(maxrate); - return MSG_task_send_with_timeout(task, alias, timeout); -} - /** * @brief Look if there is a communication on a mailbox and return the PID of the sender process. * diff --git a/src/msg/msg_private.hpp b/src/msg/msg_private.hpp index dff4ef7511..3dbb000138 100644 --- a/src/msg/msg_private.hpp +++ b/src/msg/msg_private.hpp @@ -9,7 +9,6 @@ #include "simgrid/Exception.hpp" #include "simgrid/msg.h" #include "src/kernel/activity/CommImpl.hpp" -#include "src/kernel/activity/ExecImpl.hpp" #include #include @@ -40,7 +39,9 @@ public: static Task* create_parallel(std::string name, int host_nb, const msg_host_t* host_list, double* flops_amount, double* bytes_amount, void* data); msg_error_t execute(); + msg_error_t send(std::string alias, double timeout); s4u::CommPtr send_async(std::string alias, void_f_pvoid_t cleanup, bool detached); + void cancel(); Task(const Task&) = delete; diff --git a/src/msg/msg_task.cpp b/src/msg/msg_task.cpp index 49a1b17066..803c9db153 100644 --- a/src/msg/msg_task.cpp +++ b/src/msg/msg_task.cpp @@ -129,10 +129,34 @@ s4u::CommPtr Task::send_async(std::string alias, void_f_pvoid_t cleanup, bool de return comm; } +msg_error_t Task::send(std::string alias, double timeout) +{ + msg_error_t ret = MSG_OK; + /* Try to send it */ + try { + s4u::CommPtr s4u_comm = send_async(alias, nullptr, false); + comm = s4u_comm; + comm->wait_for(timeout); + } catch (simgrid::TimeoutError& e) { + ret = MSG_TIMEOUT; + } catch (simgrid::CancelException& e) { + ret = MSG_HOST_FAILURE; + } catch (xbt_ex& e) { + if (e.category == network_error) + ret = MSG_TRANSFER_FAILURE; + else + throw; + + /* If the send failed, it is not used anymore */ + set_not_used(); + } + + return ret; +} void Task::cancel() { if (compute) { - simgrid::simix::simcall([this] { compute->cancel(); }); + compute->cancel(); } else if (comm) { comm->cancel(); } @@ -380,6 +404,86 @@ void MSG_task_dsend_bounded(msg_task_t task, const char* alias, void_f_pvoid_t c task->set_rate(maxrate); task->send_async(alias, cleanup, true); } +/** + * @brief Sends a task to a mailbox + * + * This is a blocking function, the execution flow will be blocked until the task is sent (and received on the other + * side if #MSG_task_receive is used). + * See #MSG_task_isend for sending tasks asynchronously. + * + * @param task the task to be sent + * @param alias the mailbox name to where the task is sent + * + * @return Returns #MSG_OK if the task was successfully sent, + * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE otherwise. + */ +msg_error_t MSG_task_send(msg_task_t task, const char* alias) +{ + XBT_DEBUG("MSG_task_send: Trying to send a message on mailbox '%s'", alias); + return task->send(alias, -1); +} + +/** + * @brief Sends a task to a mailbox with a maximum rate + * + * This is a blocking function, the execution flow will be blocked until the task is sent. The maxrate parameter allows + * the application to limit the bandwidth utilization of network links when sending the task. + * + * The maxrate parameter can be used to send a task with a limited bandwidth (smaller than the physical available + * value). Use MSG_task_send() if you don't limit the rate (or pass -1 as a rate value do disable this feature). + * + * @param task the task to be sent + * @param alias the mailbox name to where the task is sent + * @param maxrate the maximum communication rate for sending this task (byte/sec) + * + * @return Returns #MSG_OK if the task was successfully sent, + * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE otherwise. + */ +msg_error_t MSG_task_send_bounded(msg_task_t task, const char* alias, double maxrate) +{ + task->set_rate(maxrate); + return task->send(alias, -1); +} + +/** + * @brief Sends a task to a mailbox with a timeout + * + * This is a blocking function, the execution flow will be blocked until the task is sent or the timeout is achieved. + * + * @param task the task to be sent + * @param alias the mailbox name to where the task is sent + * @param timeout is the maximum wait time for completion (if -1, this call is the same as #MSG_task_send) + * + * @return Returns #MSG_OK if the task was successfully sent, + * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE, or #MSG_TIMEOUT otherwise. + */ +msg_error_t MSG_task_send_with_timeout(msg_task_t task, const char* alias, double timeout) +{ + return task->send(alias, timeout); +} + +/** + * @brief Sends a task to a mailbox with a timeout and with a maximum rate + * + * This is a blocking function, the execution flow will be blocked until the task is sent or the timeout is achieved. + * + * The maxrate parameter can be used to send a task with a limited bandwidth (smaller than the physical available + * value). Use MSG_task_send_with_timeout() if you don't limit the rate (or pass -1 as a rate value do disable this + * feature). + * + * @param task the task to be sent + * @param alias the mailbox name to where the task is sent + * @param timeout is the maximum wait time for completion (if -1, this call is the same as #MSG_task_send) + * @param maxrate the maximum communication rate for sending this task (byte/sec) + * + * @return Returns #MSG_OK if the task was successfully sent, + * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE, or #MSG_TIMEOUT otherwise. + */ +msg_error_t MSG_task_send_with_timeout_bounded(msg_task_t task, const char* alias, double timeout, double maxrate) +{ + task->set_rate(maxrate); + return task->send(alias, timeout); +} /** @brief Destroys the given task. * -- 2.20.1