From a581408f9f2ebe290ea6d6b1ac2939638832d1a8 Mon Sep 17 00:00:00 2001 From: Frederic Suter Date: Mon, 25 Feb 2019 17:10:19 +0100 Subject: [PATCH] end objectification of MSG tasks --- include/simgrid/msg.h | 24 +++----- src/msg/instr_msg_task.cpp | 4 +- src/msg/msg_gos.cpp | 119 +++++++++++++++++-------------------- src/msg/msg_private.hpp | 4 +- src/msg/msg_task.cpp | 81 +++++++++++-------------- 5 files changed, 104 insertions(+), 128 deletions(-) diff --git a/include/simgrid/msg.h b/include/simgrid/msg.h index f213e6eba9..daa868d20d 100644 --- a/include/simgrid/msg.h +++ b/include/simgrid/msg.h @@ -37,10 +37,17 @@ class Task; } } typedef simgrid::msg::Comm sg_msg_Comm; -typedef simgrid::msg::Task* simdata_task_t; +/** @brief Task datatype. + * + * Since most scheduling algorithms rely on a concept of task that can be either computed locally or + * transferred on another processor, it seems to be the right level of abstraction for our purposes. + * A task may then be defined by a computing amount, a message size and + * some private data. + */ +typedef simgrid::msg::Task* msg_task_t; #else typedef struct msg_Comm sg_msg_Comm; -typedef struct msg_Task* simdata_task_t; +typedef struct msg_Task* msg_task_t; #endif #ifdef __cplusplus @@ -239,19 +246,6 @@ typedef sg_msg_Comm* msg_comm_t; /* ******************************** Task ************************************ */ -typedef struct msg_task { - simdata_task_t simdata; /**< @brief simulator data */ -} s_msg_task_t; - -/** @brief Task datatype. - * - * Since most scheduling algorithms rely on a concept of task that can be either computed locally or - * transferred on another processor, it seems to be the right level of abstraction for our purposes. - * A task may then be defined by a computing amount, a message size and - * some private data. - */ - -typedef struct msg_task* msg_task_t; /** @brief Default value for an uninitialized #msg_task_t. */ #define MSG_TASK_UNINITIALIZED NULL diff --git a/src/msg/instr_msg_task.cpp b/src/msg/instr_msg_task.cpp index 57caf9808a..76da1db448 100644 --- a/src/msg/instr_msg_task.cpp +++ b/src/msg/instr_msg_task.cpp @@ -15,11 +15,11 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_msg, instr, "MSG instrumentation"); /* MSG_task_put related functions */ void TRACE_msg_task_put_start(msg_task_t task) { - XBT_DEBUG("PUT,in %p, %lld, %s", task, task->simdata->get_counter(), task->simdata->get_tracing_category().c_str()); + XBT_DEBUG("PUT,in %p, %lld, %s", task, task->get_counter(), task->get_tracing_category().c_str()); if (TRACE_actor_is_enabled()) { 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")->start_event(process_container, "SR", key); } } diff --git a/src/msg/msg_gos.cpp b/src/msg/msg_gos.cpp index e2b9431986..5738fd5773 100644 --- a/src/msg/msg_gos.cpp +++ b/src/msg/msg_gos.cpp @@ -42,16 +42,14 @@ msg_error_t MSG_parallel_task_execute(msg_task_t task) 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; } @@ -59,35 +57,33 @@ msg_error_t MSG_parallel_task_execute_with_timeout(msg_task_t task, double timeo 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(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( + 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) { @@ -97,9 +93,9 @@ msg_error_t MSG_parallel_task_execute_with_timeout(msg_task_t task, double timeo } /* 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(); @@ -252,8 +248,8 @@ msg_error_t MSG_task_receive_ext_bounded(msg_task_t * task, const char *alias, d ->set_rate(rate) ->wait_for(timeout); *task = static_cast(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) { @@ -270,7 +266,7 @@ msg_error_t MSG_task_receive_ext_bounded(msg_task_t * task, const char *alias, d 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; @@ -280,20 +276,18 @@ msg_error_t MSG_task_receive_ext_bounded(msg_task_t * task, const char *alias, d 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 @@ -304,9 +298,8 @@ static inline msg_comm_t MSG_task_isend_internal(msg_task_t task, const char* al 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; } @@ -338,7 +331,7 @@ msg_comm_t MSG_task_isend(msg_task_t task, const char *alias) */ 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); } @@ -388,7 +381,7 @@ void MSG_task_dsend(msg_task_t task, const char *alias, void_f_pvoid_t cleanup) */ 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); } @@ -453,7 +446,7 @@ int MSG_comm_test(msg_comm_t comm) 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; @@ -518,7 +511,7 @@ int MSG_comm_testany(xbt_dynar_t comms) 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(); } } @@ -546,7 +539,7 @@ msg_error_t MSG_comm_wait(msg_comm_t comm, double timeout) 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 */ @@ -622,7 +615,7 @@ int MSG_comm_waitany(xbt_dynar_t comms) 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; @@ -707,7 +700,7 @@ msg_error_t MSG_task_send(msg_task_t task, const char *alias) */ 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); } @@ -730,21 +723,20 @@ msg_error_t MSG_task_send_with_timeout(msg_task_t task, const char *alias, doubl 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; @@ -757,7 +749,7 @@ msg_error_t MSG_task_send_with_timeout(msg_task_t task, const char *alias, doubl throw; /* If the send failed, it is not used anymore */ - t_simdata->set_not_used(); + task->set_not_used(); } return ret; @@ -783,7 +775,7 @@ msg_error_t MSG_task_send_with_timeout(msg_task_t task, const char *alias, doubl */ 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); } @@ -799,7 +791,7 @@ int MSG_task_listen_from(const char *alias) { simgrid::kernel::activity::CommImplPtr comm = simgrid::s4u::Mailbox::by_name(alias)->front(); - return comm ? MSG_process_get_PID(static_cast(comm->src_buff_)->simdata->sender) : -1; + return comm ? MSG_process_get_PID(static_cast(comm->src_buff_)->sender) : -1; } /** @@ -819,18 +811,17 @@ int MSG_task_listen_from(const char *alias) */ 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()); } } @@ -845,5 +836,5 @@ void MSG_task_set_category (msg_task_t task, const char *category) */ 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(); } diff --git a/src/msg/msg_private.hpp b/src/msg/msg_private.hpp index 3ad7c43fee..14384c6cb4 100644 --- a/src/msg/msg_private.hpp +++ b/src/msg/msg_private.hpp @@ -7,9 +7,9 @@ #define MSG_PRIVATE_HPP #include "simgrid/msg.h" - #include "src/kernel/activity/CommImpl.hpp" #include "src/kernel/activity/ExecImpl.hpp" +#include static long long int msg_task_max_counter = 0; @@ -28,6 +28,8 @@ public: : name_(std::move(name)), userdata_(data), flops_amount(flops_amount), bytes_amount(bytes_amount) { counter_ = msg_task_max_counter++; + if (MC_is_active()) + MC_ignore_heap(&(counter_), sizeof(long long int)); } void set_used(); void set_not_used() { this->is_used = false; } diff --git a/src/msg/msg_task.cpp b/src/msg/msg_task.cpp index 3bfa850580..fd9544c7b6 100644 --- a/src/msg/msg_task.cpp +++ b/src/msg/msg_task.cpp @@ -7,7 +7,6 @@ #include "src/simix/smx_private.hpp" #include #include -#include #include XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_task, msg, "Logging specific to MSG (task)"); @@ -61,14 +60,7 @@ void Task::report_multiple_use() const */ 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 @@ -96,19 +88,18 @@ msg_task_t MSG_parallel_task_create(const char *name, int host_nb, const msg_hos // 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; @@ -117,13 +108,13 @@ msg_task_t MSG_parallel_task_create(const char *name, int host_nb, const msg_hos /** @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. @@ -143,25 +134,25 @@ void MSG_task_set_copy_callback(void (*callback) (msg_task_t task, msg_process_t /** @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. @@ -176,13 +167,12 @@ void MSG_task_set_name(msg_task_t task, const char *name) */ 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; @@ -196,13 +186,12 @@ msg_error_t MSG_task_cancel(msg_task_t task) { 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; } @@ -214,12 +203,12 @@ msg_error_t MSG_task_cancel(msg_task_t task) 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; } } @@ -231,13 +220,13 @@ double MSG_task_get_remaining_work_ratio(msg_task_t task) { * 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; } } @@ -249,7 +238,7 @@ double MSG_task_get_flops_amount(msg_task_t task) { */ 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. @@ -258,7 +247,7 @@ void MSG_task_set_flops_amount(msg_task_t task, double flops_amount) */ 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 @@ -268,15 +257,15 @@ void MSG_task_set_bytes_amount(msg_task_t task, double data_size) */ 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. @@ -286,8 +275,8 @@ double MSG_task_get_bytes_amount(msg_task_t 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). @@ -298,5 +287,5 @@ void MSG_task_set_bound(msg_task_t task, double bound) { 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; } -- 2.20.1