msg_error_t MSG_parallel_task_execute_with_timeout(msg_task_t task, double timeout)
{
- simdata_task_t simdata = task->simdata;
e_smx_state_t comp_state;
msg_error_t status = MSG_OK;
-
- xbt_assert((not simdata->compute) && not task->simdata->isused,
- "This task is executed somewhere else. Go fix your code!");
+ xbt_assert((not task->compute) && not task->is_used, "This task is executed somewhere else. Go fix your code!");
XBT_DEBUG("Computing on %s", MSG_process_get_name(MSG_process_self()));
- if (simdata->flops_amount <= 0.0 && not simdata->host_nb) {
+ if (task->flops_amount <= 0.0 && not task->host_nb) {
return MSG_OK;
}
simgrid::instr::Container::by_name(instr_pid(MSG_process_self()))->get_state("ACTOR_STATE")->push_event("execute");
try {
- simdata->setUsed();
-
- if (simdata->host_nb > 0) {
- simdata->compute =
- boost::static_pointer_cast<simgrid::kernel::activity::ExecImpl>(simcall_execution_parallel_start(
- task->name ?: "", simdata->host_nb, simdata->host_list, simdata->flops_parallel_amount,
- simdata->bytes_parallel_amount, -1.0, timeout));
- XBT_DEBUG("Parallel execution action created: %p", simdata->compute.get());
- if (task->category != nullptr)
- simgrid::simix::simcall([task] { task->simdata->compute->set_category(task->category); });
+ task->set_used();
+
+ if (task->host_nb > 0) {
+ task->compute = boost::static_pointer_cast<simgrid::kernel::activity::ExecImpl>(
+ simcall_execution_parallel_start(std::move(task->get_name()), task->host_nb, task->host_list,
+ task->flops_parallel_amount, task->bytes_parallel_amount, -1.0, timeout));
+ XBT_DEBUG("Parallel execution action created: %p", task->compute.get());
+ if (task->has_tracing_category())
+ simgrid::simix::simcall([task] { task->compute->set_category(std::move(task->get_tracing_category())); });
} else {
sg_host_t host = MSG_process_get_host(MSG_process_self());
- simdata->compute = simgrid::simix::simcall([task, host] {
- return simgrid::kernel::activity::ExecImplPtr(
- new simgrid::kernel::activity::ExecImpl(task->name ?: "", task->category ?: "",
- /*timeout_detector*/ nullptr, host));
+ task->compute = simgrid::simix::simcall([task, host] {
+ return simgrid::kernel::activity::ExecImplPtr(new simgrid::kernel::activity::ExecImpl(
+ std::move(task->get_name()), std::move(task->get_tracing_category()), host));
});
/* checking for infinite values */
- xbt_assert(std::isfinite(simdata->flops_amount), "flops_amount is not finite!");
- xbt_assert(std::isfinite(simdata->priority), "priority is not finite!");
+ xbt_assert(std::isfinite(task->flops_amount), "flops_amount is not finite!");
+ xbt_assert(std::isfinite(task->priority), "priority is not finite!");
- simdata->compute->start(simdata->flops_amount, simdata->priority, simdata->bound);
+ task->compute->start(task->flops_amount, task->priority, task->bound);
}
- comp_state = simcall_execution_wait(simdata->compute);
+ comp_state = simcall_execution_wait(task->compute);
- simdata->setNotUsed();
+ task->set_not_used();
- XBT_DEBUG("Execution task '%s' finished in state %d", task->name, (int)comp_state);
+ XBT_DEBUG("Execution task '%s' finished in state %d", task->get_cname(), (int)comp_state);
} catch (simgrid::HostFailureException& e) {
status = MSG_HOST_FAILURE;
} catch (simgrid::TimeoutError& e) {
}
/* action ended, set comm and compute = nullptr, the actions is already destroyed in the main function */
- simdata->flops_amount = 0.0;
- simdata->comm = nullptr;
- simdata->compute = nullptr;
+ task->flops_amount = 0.0;
+ task->comm = nullptr;
+ task->compute = nullptr;
if (TRACE_actor_is_enabled())
simgrid::instr::Container::by_name(instr_pid(MSG_process_self()))->get_state("ACTOR_STATE")->pop_event();
double rate)
{
XBT_DEBUG("MSG_task_receive_ext: Trying to receive a message on mailbox '%s'", alias);
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(alias);
msg_error_t ret = MSG_OK;
/* We no longer support getting a task from a specific host */
if (host)
/* Try to receive it by calling SIMIX network layer */
try {
void* payload;
- mailbox->get_init()->set_dst_data(&payload, sizeof(msg_task_t*))->set_rate(rate)->wait_for(timeout);
+ simgrid::s4u::Mailbox::by_name(alias)
+ ->get_init()
+ ->set_dst_data(&payload, sizeof(msg_task_t*))
+ ->set_rate(rate)
+ ->wait_for(timeout);
*task = static_cast<msg_task_t>(payload);
- XBT_DEBUG("Got task %s from %s", (*task)->name, mailbox->get_cname());
- (*task)->simdata->setNotUsed();
+ XBT_DEBUG("Got task %s from %s", (*task)->get_cname(), alias);
+ (*task)->set_not_used();
} catch (simgrid::HostFailureException& e) {
ret = MSG_HOST_FAILURE;
} catch (simgrid::TimeoutError& e) {
ret = MSG_TIMEOUT;
} catch (simgrid::CancelException& e) {
- ret = MSG_HOST_FAILURE;
+ ret = MSG_TASK_CANCELED;
} catch (xbt_ex& e) {
if (e.category == network_error)
ret = MSG_TRANSFER_FAILURE;
throw;
}
- if (ret != MSG_HOST_FAILURE && ret != MSG_TRANSFER_FAILURE && ret != MSG_TIMEOUT) {
- TRACE_msg_task_get_end(*task);
+ if (TRACE_actor_is_enabled() && ret != MSG_HOST_FAILURE && ret != MSG_TRANSFER_FAILURE && ret != MSG_TIMEOUT) {
+ container_t process_container = simgrid::instr::Container::by_name(instr_pid(MSG_process_self()));
+
+ std::string key = std::string("p") + std::to_string((*task)->get_id());
+ simgrid::instr::Container::get_root()->get_link("ACTOR_TASK_LINK")->end_event(process_container, "SR", key);
}
return ret;
}
/* Internal function used to factorize code between MSG_task_isend(), MSG_task_isend_bounded(), and MSG_task_dsend(). */
-static inline msg_comm_t MSG_task_isend_internal(msg_task_t task, const char* alias,
- void_f_pvoid_t cleanup, int detached)
+static inline msg_comm_t MSG_task_isend_internal(msg_task_t task, const char* alias, void_f_pvoid_t cleanup,
+ bool detached)
{
- simdata_task_t t_simdata = nullptr;
msg_process_t myself = MSG_process_self();
simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(alias);
TRACE_msg_task_put_start(task);
/* Prepare the task to send */
- t_simdata = task->simdata;
- t_simdata->sender = myself;
- t_simdata->source = MSG_host_self();
- t_simdata->setUsed();
- t_simdata->comm = nullptr;
+ task->sender = myself;
+ task->set_used();
+ task->comm = nullptr;
msg_global->sent_msg++;
- /* Send it by calling SIMIX network layer */
- smx_activity_t act =
- simcall_comm_isend(myself->get_impl(), mailbox->get_impl(), t_simdata->bytes_amount, t_simdata->rate, task,
- sizeof(void*), nullptr, cleanup, nullptr, nullptr, detached);
- t_simdata->comm = boost::static_pointer_cast<simgrid::kernel::activity::CommImpl>(act);
+ simgrid::s4u::CommPtr comm = mailbox->put_init(task, task->bytes_amount)->set_rate(task->rate);
+ task->comm = comm;
+ if (detached)
+ comm->detach(cleanup);
+ else
+ comm->start();
- msg_comm_t comm = nullptr;
+ msg_comm_t msg_comm = nullptr;
if (not detached) {
- comm = new simgrid::msg::Comm(task, nullptr, act);
+ msg_comm = new simgrid::msg::Comm(task, nullptr, comm);
}
- if (TRACE_is_enabled() && task->category != nullptr)
- simgrid::simix::simcall([act, task] { act->set_category(task->category); });
+ if (TRACE_is_enabled() && task->has_tracing_category())
+ simgrid::simix::simcall([comm, task] { comm->get_impl()->set_category(std::move(task->get_tracing_category())); });
- TRACE_msg_task_put_end();
-
- return comm;
+ return msg_comm;
}
/**
*/
msg_comm_t MSG_task_isend(msg_task_t task, const char *alias)
{
- return MSG_task_isend_internal(task, alias, nullptr, 0);
+ return MSG_task_isend_internal(task, alias, nullptr, false);
}
/**
*/
msg_comm_t MSG_task_isend_bounded(msg_task_t task, const char *alias, double maxrate)
{
- task->simdata->rate = maxrate;
- return MSG_task_isend_internal(task, alias, nullptr, 0);
+ task->rate = maxrate;
+ return MSG_task_isend_internal(task, alias, nullptr, false);
}
/**
*/
void MSG_task_dsend(msg_task_t task, const char *alias, void_f_pvoid_t cleanup)
{
- msg_comm_t XBT_ATTRIB_UNUSED comm = MSG_task_isend_internal(task, alias, cleanup, 1);
+ msg_comm_t XBT_ATTRIB_UNUSED comm = MSG_task_isend_internal(task, alias, cleanup, true);
xbt_assert(comm == nullptr);
}
*/
void MSG_task_dsend_bounded(msg_task_t task, const char *alias, void_f_pvoid_t cleanup, double maxrate)
{
- task->simdata->rate = maxrate;
+ task->rate = maxrate;
MSG_task_dsend(task, alias, cleanup);
}
/* Try to receive it by calling SIMIX network layer */
msg_comm_t comm = new simgrid::msg::Comm(
- nullptr, task,
- simcall_comm_irecv(SIMIX_process_self(), mbox->get_impl(), task, nullptr, nullptr, nullptr, nullptr, rate));
+ nullptr, task, mbox->get_init()->set_dst_data((void**)task, sizeof(msg_task_t*))->set_rate(rate)->start());
return comm;
}
bool finished = false;
try {
- finished = simcall_comm_test(comm->s_comm);
+ finished = comm->s_comm->test();
if (finished && comm->task_received != nullptr) {
/* I am the receiver */
- (*comm->task_received)->simdata->setNotUsed();
+ (*comm->task_received)->set_not_used();
}
} catch (simgrid::TimeoutError& e) {
comm->status = MSG_TIMEOUT;
finished = true;
+ } catch (simgrid::CancelException& e) {
+ comm->status = MSG_TASK_CANCELED;
+ finished = true;
}
catch (xbt_ex& e) {
if (e.category == network_error) {
msg_comm_t comm;
unsigned int cursor;
xbt_dynar_foreach(comms, cursor, comm) {
- s_comms.push_back(static_cast<simgrid::kernel::activity::CommImpl*>(comm->s_comm.get()));
+ s_comms.push_back(static_cast<simgrid::kernel::activity::CommImpl*>(comm->s_comm->get_impl().get()));
}
msg_error_t status = MSG_OK;
} catch (simgrid::TimeoutError& e) {
finished_index = e.value;
status = MSG_TIMEOUT;
+ } catch (simgrid::CancelException& e) {
+ finished_index = e.value;
+ status = MSG_TASK_CANCELED;
}
catch (xbt_ex& e) {
if (e.category != network_error)
if (status == MSG_OK && comm->task_received != nullptr) {
/* I am the receiver */
- (*comm->task_received)->simdata->setNotUsed();
+ (*comm->task_received)->set_not_used();
}
}
msg_error_t MSG_comm_wait(msg_comm_t comm, double timeout)
{
try {
- simcall_comm_wait(comm->s_comm, timeout);
+ comm->s_comm->wait_for(timeout);
if (comm->task_received != nullptr) {
/* I am the receiver */
- (*comm->task_received)->simdata->setNotUsed();
+ (*comm->task_received)->set_not_used();
}
/* FIXME: these functions are not traceable */
} catch (simgrid::TimeoutError& e) {
comm->status = MSG_TIMEOUT;
+ } catch (simgrid::CancelException& e) {
+ comm->status = MSG_TASK_CANCELED;
}
catch (xbt_ex& e) {
if (e.category == network_error)
msg_comm_t comm;
unsigned int cursor;
xbt_dynar_foreach(comms, cursor, comm) {
- s_comms.push_back(static_cast<simgrid::kernel::activity::CommImpl*>(comm->s_comm.get()));
+ s_comms.push_back(static_cast<simgrid::kernel::activity::CommImpl*>(comm->s_comm->get_impl().get()));
}
msg_error_t status = MSG_OK;
} catch (simgrid::TimeoutError& e) {
finished_index = e.value;
status = MSG_TIMEOUT;
+ } catch (simgrid::CancelException& e) {
+ finished_index = e.value;
+ status = MSG_TASK_CANCELED;
}
catch(xbt_ex& e) {
if (e.category == network_error) {
if (comm->task_received != nullptr) {
/* I am the receiver */
- (*comm->task_received)->simdata->setNotUsed();
+ (*comm->task_received)->set_not_used();
}
return finished_index;
*/
msg_error_t MSG_task_send_bounded(msg_task_t task, const char *alias, double maxrate)
{
- task->simdata->rate = maxrate;
+ task->rate = maxrate;
return MSG_task_send(task, alias);
}
msg_error_t MSG_task_send_with_timeout(msg_task_t task, const char *alias, double timeout)
{
msg_error_t ret = MSG_OK;
- simdata_task_t t_simdata = nullptr;
- msg_process_t process = MSG_process_self();
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(alias);
TRACE_msg_task_put_start(task);
/* Prepare the task to send */
- t_simdata = task->simdata;
- t_simdata->sender = process;
- t_simdata->source = MSG_host_self();
+ task->sender = MSG_process_self();
+ task->set_used();
- t_simdata->setUsed();
-
- t_simdata->comm = nullptr;
msg_global->sent_msg++;
- /* Try to send it by calling SIMIX network layer */
+ /* Try to send it */
try {
- simgrid::s4u::CommPtr comm = mailbox->put_init(task, t_simdata->bytes_amount)->set_rate(t_simdata->rate);
- t_simdata->comm = boost::static_pointer_cast<simgrid::kernel::activity::CommImpl>(comm->get_impl());
+ simgrid::s4u::CommPtr comm =
+ simgrid::s4u::Mailbox::by_name(alias)->put_init(task, task->bytes_amount)->set_rate(task->rate);
+ task->comm = comm;
comm->start();
- if (TRACE_is_enabled() && task->category != nullptr)
- simgrid::simix::simcall([comm, task] { comm->get_impl()->set_category(task->category); });
+ if (TRACE_is_enabled() && task->has_tracing_category())
+ simgrid::simix::simcall(
+ [comm, task] { comm->get_impl()->set_category(std::move(task->get_tracing_category())); });
comm->wait_for(timeout);
} catch (simgrid::TimeoutError& e) {
ret = MSG_TIMEOUT;
throw;
/* If the send failed, it is not used anymore */
- t_simdata->setNotUsed();
+ task->set_not_used();
}
return ret;
*/
msg_error_t MSG_task_send_with_timeout_bounded(msg_task_t task, const char *alias, double timeout, double maxrate)
{
- task->simdata->rate = maxrate;
+ task->rate = maxrate;
return MSG_task_send_with_timeout(task, alias, timeout);
}
{
simgrid::kernel::activity::CommImplPtr comm = simgrid::s4u::Mailbox::by_name(alias)->front();
- return comm ? MSG_process_get_PID(static_cast<msg_task_t>(comm->src_buff_)->simdata->sender) : -1;
+ return comm ? MSG_process_get_PID(static_cast<msg_task_t>(comm->src_buff_)->sender) : -1;
}
/**
*/
void MSG_task_set_category (msg_task_t task, const char *category)
{
- TRACE_msg_set_task_category (task, category);
+ xbt_assert(not task->has_tracing_category(), "Task %p(%s) already has a category (%s).", task, task->get_cname(),
+ task->get_tracing_category().c_str());
+
+ // if user provides a nullptr category, task is no longer traced
+ if (category == nullptr) {
+ task->set_tracing_category("");
+ XBT_DEBUG("MSG task %p(%s), category removed", task, task->get_cname());
+ } else {
+ // set task category
+ task->set_tracing_category(category);
+ XBT_DEBUG("MSG task %p(%s), category %s", task, task->get_cname(), task->get_tracing_category().c_str());
+ }
}
/**
*/
const char *MSG_task_get_category (msg_task_t task)
{
- return task->category;
+ return task->get_tracing_category().c_str();
}
