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->is_used,
- "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->set_used();
-
- if (simdata->host_nb > 0) {
- simdata->compute =
- boost::static_pointer_cast<simgrid::kernel::activity::ExecImpl>(simcall_execution_parallel_start(
- std::move(task->simdata->get_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->simdata->has_tracing_category())
- simgrid::simix::simcall(
- [task] { task->simdata->compute->set_category(std::move(task->simdata->get_tracing_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] {
+ task->compute = simgrid::simix::simcall([task, host] {
return simgrid::kernel::activity::ExecImplPtr(new simgrid::kernel::activity::ExecImpl(
- std::move(task->simdata->get_name()), std::move(task->simdata->get_tracing_category()), host));
+ 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->set_not_used();
+ task->set_not_used();
- XBT_DEBUG("Execution task '%s' finished in state %d", task->simdata->get_cname(), (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();
->set_rate(rate)
->wait_for(timeout);
*task = static_cast<msg_task_t>(payload);
- XBT_DEBUG("Got task %s from %s", (*task)->simdata->get_cname(), alias);
- (*task)->simdata->set_not_used();
+ 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) {
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)->simdata->get_counter());
+ std::string key = std::string("p") + std::to_string((*task)->get_counter());
simgrid::instr::Container::get_root()->get_link("ACTOR_TASK_LINK")->end_event(process_container, "SR", key);
}
return ret;
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->set_used();
- t_simdata->comm = nullptr;
+ task->sender = myself;
+ task->set_used();
+ task->comm = nullptr;
msg_global->sent_msg++;
- simgrid::s4u::CommPtr comm = mailbox->put_init(task, t_simdata->bytes_amount)->set_rate(t_simdata->rate);
- t_simdata->comm = comm;
+ simgrid::s4u::CommPtr comm = mailbox->put_init(task, task->bytes_amount)->set_rate(task->rate);
+ task->comm = comm;
if (detached)
comm->detach(cleanup);
else
msg_comm = new simgrid::msg::Comm(task, nullptr, comm);
}
- if (TRACE_is_enabled() && task->simdata->has_tracing_category())
- simgrid::simix::simcall(
- [comm, task] { comm->get_impl()->set_category(std::move(task->simdata->get_tracing_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())); });
return msg_comm;
}
*/
msg_comm_t MSG_task_isend_bounded(msg_task_t task, const char *alias, double maxrate)
{
- task->simdata->rate = maxrate;
+ task->rate = maxrate;
return MSG_task_isend_internal(task, alias, nullptr, false);
}
*/
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);
}
finished = comm->s_comm->test();
if (finished && comm->task_received != nullptr) {
/* I am the receiver */
- (*comm->task_received)->simdata->set_not_used();
+ (*comm->task_received)->set_not_used();
}
} catch (simgrid::TimeoutError& e) {
comm->status = MSG_TIMEOUT;
if (status == MSG_OK && comm->task_received != nullptr) {
/* I am the receiver */
- (*comm->task_received)->simdata->set_not_used();
+ (*comm->task_received)->set_not_used();
}
}
if (comm->task_received != nullptr) {
/* I am the receiver */
- (*comm->task_received)->simdata->set_not_used();
+ (*comm->task_received)->set_not_used();
}
/* FIXME: these functions are not traceable */
if (comm->task_received != nullptr) {
/* I am the receiver */
- (*comm->task_received)->simdata->set_not_used();
+ (*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);
}
TRACE_msg_task_put_start(task);
/* Prepare the task to send */
- simdata_task_t t_simdata = task->simdata;
- t_simdata->sender = MSG_process_self();
- t_simdata->set_used();
+ task->sender = MSG_process_self();
+ task->set_used();
msg_global->sent_msg++;
/* Try to send it */
try {
simgrid::s4u::CommPtr comm =
- simgrid::s4u::Mailbox::by_name(alias)->put_init(task, t_simdata->bytes_amount)->set_rate(t_simdata->rate);
- t_simdata->comm = 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->simdata->has_tracing_category())
+ if (TRACE_is_enabled() && task->has_tracing_category())
simgrid::simix::simcall(
- [comm, task] { comm->get_impl()->set_category(std::move(task->simdata->get_tracing_category())); });
+ [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->set_not_used();
+ 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)
{
- xbt_assert(not task->simdata->has_tracing_category(), "Task %p(%s) already has a category (%s).", task,
- task->simdata->get_cname(), task->simdata->get_tracing_category().c_str());
+ 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->simdata->set_tracing_category("");
- XBT_DEBUG("MSG task %p(%s), category removed", task, task->simdata->get_cname());
+ task->set_tracing_category("");
+ XBT_DEBUG("MSG task %p(%s), category removed", task, task->get_cname());
} else {
// set task category
- task->simdata->set_tracing_category(category);
- XBT_DEBUG("MSG task %p(%s), category %s", task, task->simdata->get_cname(),
- task->simdata->get_tracing_category().c_str());
+ 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->simdata->get_tracing_category().c_str();
+ return task->get_tracing_category().c_str();
}
#include "src/simix/smx_private.hpp"
#include <algorithm>
#include <cmath>
-#include <simgrid/modelchecker.h>
#include <simgrid/s4u/Comm.hpp>
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_task, msg, "Logging specific to MSG (task)");
*/
msg_task_t MSG_task_create(const char *name, double flop_amount, double message_size, void *data)
{
- msg_task_t task = new s_msg_task_t;
- /* Simulator Data */
- task->simdata = new simgrid::msg::Task(name ? name : "", flop_amount, message_size, data);
-
- if (MC_is_active())
- MC_ignore_heap(&(task->simdata->get_counter()), sizeof(long long int));
-
- return task;
+ return new simgrid::msg::Task(name ? name : "", flop_amount, message_size, data);
}
/** @brief Creates a new parallel task
// Task's flops amount is set to an arbitrary value > 0.0 to be able to distinguish, in
// MSG_task_get_remaining_work_ratio(), a finished task and a task that has not started yet.
msg_task_t task = MSG_task_create(name, 1.0, 0, data);
- simdata_task_t simdata = task->simdata;
/* Simulator Data specific to parallel tasks */
- simdata->host_nb = host_nb;
- simdata->host_list = new sg_host_t[host_nb];
- std::copy_n(host_list, host_nb, simdata->host_list);
+ task->host_nb = host_nb;
+ host_list = new sg_host_t[host_nb];
+ std::copy_n(host_list, host_nb, task->host_list);
if (flops_amount != nullptr) {
- simdata->flops_parallel_amount = new double[host_nb];
- std::copy_n(flops_amount, host_nb, simdata->flops_parallel_amount);
+ task->flops_parallel_amount = new double[host_nb];
+ std::copy_n(flops_amount, host_nb, task->flops_parallel_amount);
}
if (bytes_amount != nullptr) {
- simdata->bytes_parallel_amount = new double[host_nb * host_nb];
- std::copy_n(bytes_amount, host_nb * host_nb, simdata->bytes_parallel_amount);
+ task->bytes_parallel_amount = new double[host_nb * host_nb];
+ std::copy_n(bytes_amount, host_nb * host_nb, task->bytes_parallel_amount);
}
return task;
/** @brief Return the user data of the given task */
void* MSG_task_get_data(msg_task_t task)
{
- return (task->simdata->get_user_data());
+ return task->get_user_data();
}
/** @brief Sets the user data of a given task */
void MSG_task_set_data(msg_task_t task, void *data)
{
- task->simdata->set_user_data(data);
+ task->set_user_data(data);
}
/** @brief Sets a function to be called when a task has just been copied.
/** @brief Returns the sender of the given task */
msg_process_t MSG_task_get_sender(msg_task_t task)
{
- return task->simdata->sender;
+ return task->sender;
}
/** @brief Returns the source (the sender's host) of the given task */
msg_host_t MSG_task_get_source(msg_task_t task)
{
- return task->simdata->sender->get_host();
+ return task->sender->get_host();
}
/** @brief Returns the name of the given task. */
const char *MSG_task_get_name(msg_task_t task)
{
- return task->simdata->get_cname();
+ return task->get_cname();
}
/** @brief Sets the name of the given task. */
void MSG_task_set_name(msg_task_t task, const char *name)
{
- task->simdata->set_name(name);
+ task->set_name(name);
}
/** @brief Destroys the given task.
*/
msg_error_t MSG_task_destroy(msg_task_t task)
{
- if (task->simdata->is_used) {
+ if (task->is_used) {
/* the task is being sent or executed: cancel it first */
MSG_task_cancel(task);
}
/* free main structures */
- delete task->simdata;
delete task;
return MSG_OK;
{
xbt_assert((task != nullptr), "Cannot cancel a nullptr task");
- simdata_task_t simdata = task->simdata;
- if (simdata->compute) {
- simgrid::simix::simcall([simdata] { simdata->compute->cancel(); });
- } else if (simdata->comm) {
- simdata->comm->cancel();
+ if (task->compute) {
+ simgrid::simix::simcall([task] { task->compute->cancel(); });
+ } else if (task->comm) {
+ task->comm->cancel();
}
- simdata->set_not_used();
+ task->set_not_used();
return MSG_OK;
}
double MSG_task_get_remaining_work_ratio(msg_task_t task) {
xbt_assert((task != nullptr), "Cannot get information from a nullptr task");
- if (task->simdata->compute) {
+ if (task->compute) {
// Task in progress
- return task->simdata->compute->get_remaining_ratio();
+ return task->compute->get_remaining_ratio();
} else {
// Task not started (flops_amount is > 0.0) or finished (flops_amount is set to 0.0)
- return task->simdata->flops_amount > 0.0 ? 1.0 : 0.0;
+ return task->flops_amount > 0.0 ? 1.0 : 0.0;
}
}
* So you will get an exception if you call this function on parallel tasks. Just don't do it.
*/
double MSG_task_get_flops_amount(msg_task_t task) {
- if (task->simdata->compute != nullptr) {
- return task->simdata->compute->get_remaining();
+ if (task->compute != nullptr) {
+ return task->compute->get_remaining();
} else {
// Not started or already done.
// - Before starting, flops_amount is initially the task cost
// - After execution, flops_amount is set to 0 (until someone uses MSG_task_set_flops_amount, if any)
- return task->simdata->flops_amount;
+ return task->flops_amount;
}
}
*/
void MSG_task_set_flops_amount(msg_task_t task, double flops_amount)
{
- task->simdata->flops_amount = flops_amount;
+ task->flops_amount = flops_amount;
}
/** @brief set the amount data attached with the given task.
*/
void MSG_task_set_bytes_amount(msg_task_t task, double data_size)
{
- task->simdata->bytes_amount = data_size;
+ task->bytes_amount = data_size;
}
/** @brief Returns the total amount received by the given task
*/
double MSG_task_get_remaining_communication(msg_task_t task)
{
- XBT_DEBUG("calling simcall_communication_get_remains(%p)", task->simdata->comm.get());
- return task->simdata->comm->get_remaining();
+ XBT_DEBUG("calling simcall_communication_get_remains(%p)", task->comm.get());
+ return task->comm->get_remaining();
}
/** @brief Returns the size of the data attached to the given task. */
double MSG_task_get_bytes_amount(msg_task_t task)
{
- xbt_assert((task != nullptr) && (task->simdata != nullptr), "Invalid parameter");
- return task->simdata->bytes_amount;
+ xbt_assert(task != nullptr, "Invalid parameter");
+ return task->bytes_amount;
}
/** @brief Changes the priority of a computation task.
*/
void MSG_task_set_priority(msg_task_t task, double priority)
{
- task->simdata->priority = 1 / priority;
- xbt_assert(std::isfinite(task->simdata->priority), "priority is not finite!");
+ task->priority = 1 / priority;
+ xbt_assert(std::isfinite(task->priority), "priority is not finite!");
}
/** @brief Changes the maximum CPU utilization of a computation task (in flops/s).
{
if (bound < 1e-12) /* close enough to 0 without any floating precision surprise */
XBT_INFO("bound == 0 means no capping (i.e., unlimited).");
- task->simdata->bound = bound;
+ task->bound = bound;
}