Task* Task::create_parallel(const std::string& name, int host_nb, const msg_host_t* host_list, double* flops_amount,
double* bytes_amount, void* data)
{
- std::vector<simgrid::s4u::Host*> hosts(host_list, host_list + host_nb);
+ std::vector<s4u::Host*> hosts(host_list, host_list + host_nb);
std::vector<double> flops;
std::vector<double> bytes;
if (flops_amount != nullptr)
set_not_used();
XBT_DEBUG("Execution task '%s' finished", get_cname());
- } catch (HostFailureException& e) {
+ } catch (const HostFailureException&) {
status = MSG_HOST_FAILURE;
- } catch (TimeoutError& e) {
+ } catch (const TimeoutException&) {
status = MSG_TIMEOUT;
- } catch (CancelException& e) {
+ } catch (const CancelException&) {
status = MSG_TASK_CANCELED;
}
s4u::CommPtr Task::send_async(const std::string& alias, void_f_pvoid_t cleanup, bool detached)
{
if (TRACE_actor_is_enabled()) {
- container_t process_container = simgrid::instr::Container::by_name(instr_pid(*MSG_process_self()));
+ container_t process_container = instr::Container::by_name(instr_pid(*MSG_process_self()));
std::string key = std::string("p") + std::to_string(get_id());
- simgrid::instr::Container::get_root()->get_link("ACTOR_TASK_LINK")->start_event(process_container, "SR", key);
+ instr::Container::get_root()->get_link("ACTOR_TASK_LINK")->start_event(process_container, "SR", key);
}
/* Prepare the task to send */
msg_global->sent_msg++;
s4u::CommPtr s4u_comm = s4u::Mailbox::by_name(alias)->put_init(this, bytes_amount)->set_rate(get_rate());
+ if (TRACE_is_enabled() && has_tracing_category())
+ s4u_comm->set_tracing_category(tracing_category_);
+
comm = s4u_comm;
if (detached)
else
comm->start();
- if (TRACE_is_enabled() && has_tracing_category())
- simgrid::simix::simcall([this] { comm->get_impl()->set_category(std::move(tracing_category_)); });
-
return comm;
}
s4u::CommPtr s4u_comm = send_async(alias, nullptr, false);
comm = s4u_comm;
comm->wait_for(timeout);
- } catch (simgrid::TimeoutError& e) {
+ } catch (const TimeoutException&) {
ret = MSG_TIMEOUT;
- } catch (simgrid::CancelException& e) {
+ } catch (const CancelException&) {
ret = MSG_HOST_FAILURE;
- } catch (xbt_ex& e) {
- if (e.category == network_error)
- ret = MSG_TRANSFER_FAILURE;
- else
- throw;
-
+ } catch (const NetworkFailureException&) {
+ ret = MSG_TRANSFER_FAILURE;
/* If the send failed, it is not used anymore */
set_not_used();
}
s4u::Actor* Task::get_sender()
{
- return comm ? comm->get_sender().get() : nullptr;
+ return comm ? comm->get_sender() : nullptr;
}
s4u::Host* Task::get_source()
task->set_user_data(data);
}
-/** @brief Sets a function to be called when a task has just been copied.
- * @param callback a callback function
- */
-// deprecated
-void MSG_task_set_copy_callback(void (*callback) (msg_task_t task, msg_process_t sender, msg_process_t receiver)) {
-
- msg_global->task_copy_callback = callback;
-
- if (callback) {
- SIMIX_comm_set_copy_data_callback(MSG_comm_copy_data_from_SIMIX);
- } else {
- SIMIX_comm_set_copy_data_callback(SIMIX_comm_copy_pointer_callback);
- }
-}
-
/** @brief Returns the sender of the given task */
msg_process_t MSG_task_get_sender(msg_task_t task)
{
return MSG_task_receive_ext_bounded(task, alias, timeout, nullptr, rate);
}
-/**
- * @brief Receives a task from a mailbox from a specific host with a given timeout.
- *
- * This is a blocking function with a timeout, the execution flow will be blocked until the task is received or the
- * timeout is achieved. See #MSG_task_irecv for receiving tasks asynchronously. You can provide a -1 timeout
- * to obtain an infinite timeout.
- *
- * @param task a memory location for storing a #msg_task_t.
- * @param alias name of the mailbox to receive the task from
- * @param timeout is the maximum wait time for completion (provide -1 for no timeout)
- * @param host a #msg_host_t host from where the task was sent
- *
- * @return Returns
- * #MSG_OK if the task was successfully received,
- * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE, or #MSG_TIMEOUT otherwise.
- */
-msg_error_t MSG_task_receive_ext(msg_task_t* task, const char* alias, double timeout, msg_host_t host)
-{
- XBT_DEBUG("MSG_task_receive_ext: Trying to receive a message on mailbox '%s'", alias);
- return MSG_task_receive_ext_bounded(task, alias, timeout, host, -1.0);
-}
-
/**
* @brief Receives a task from a mailbox from a specific host with a given timeout and at a given rate.
*
*task = static_cast<msg_task_t>(payload);
XBT_DEBUG("Got task %s from %s", (*task)->get_cname(), alias);
(*task)->set_not_used();
- } catch (simgrid::HostFailureException& e) {
+ } catch (const simgrid::HostFailureException&) {
ret = MSG_HOST_FAILURE;
- } catch (simgrid::TimeoutError& e) {
+ } catch (const simgrid::TimeoutException&) {
ret = MSG_TIMEOUT;
- } catch (simgrid::CancelException& e) {
+ } catch (const simgrid::CancelException&) {
ret = MSG_TASK_CANCELED;
- } catch (xbt_ex& e) {
- if (e.category == network_error)
- ret = MSG_TRANSFER_FAILURE;
- else
- throw;
+ } catch (const simgrid::NetworkFailureException&) {
+ ret = MSG_TRANSFER_FAILURE;
}
if (TRACE_actor_is_enabled() && ret != MSG_HOST_FAILURE && ret != MSG_TRANSFER_FAILURE && ret != MSG_TIMEOUT) {
*
* @param alias the name of the mailbox to be considered
*
- * @return Returns the PID of sender process,
- * -1 if there is no communication in the mailbox.#include <cmath>
+ * @return Returns the PID of sender process (or -1 if there is no communication in the mailbox)
*
*/
int MSG_task_listen_from(const char* alias)
