end objectification of MSG tasks

diff --git a/include/simgrid/msg.h b/include/simgrid/msg.h
index f213e6e..daa868d 100644 (file)
--- 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::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 <em>computed</em> locally or
+ *  <em>transferred</em> on another processor, it seems to be the right level of abstraction for our purposes.
+ *  A <em>task</em> may then be defined by a <em>computing amount</em>, a <em>message size</em> and
+ *  some <em>private data</em>.
+ */
+typedef simgrid::msg::Task* msg_task_t;

 #else
 typedef struct msg_Comm sg_msg_Comm;
 #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
 #endif
 
 #ifdef __cplusplus


@@ -239,19 +246,6 @@ typedef sg_msg_Comm* msg_comm_t;
 
 /* ******************************** Task ************************************ */
 
 
 /* ******************************** 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 <em>computed</em> locally or
- *  <em>transferred</em> on another processor, it seems to be the right level of abstraction for our purposes.
- *  A <em>task</em> may then be defined by a <em>computing amount</em>, a <em>message size</em> and
- *  some <em>private data</em>.
- */
-
-typedef struct msg_task* msg_task_t;

 
 /** @brief Default value for an uninitialized #msg_task_t. */
 #define MSG_TASK_UNINITIALIZED NULL
 
 /** @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 57caf98..76da1db 100644 (file)
--- 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)
 {
 /* 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()));
 
   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);
   }
 }
     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 e2b9431..5738fd5 100644 (file)
--- 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)
 {
 
 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;
 
   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()));
 
 
   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;
   }
 
     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 {
     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());
     } 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(
         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 */
       });
       /* 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) {
   } 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 */
   }
 
   /* 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();
 
   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<msg_task_t>(payload);
         ->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) {
   } 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()));
 
   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;
     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)
 {
 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 */
   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++;
 
   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
   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);
   }
 
     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;
 }
 
   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)
 {
  */
 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);
 }
 
   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)
 {
  */
 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);
 }
 
   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 */
     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;
     }
   } 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 */
 
     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 */
 
     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 */
     }
 
     /* 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 */
 
   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;
   }
 
   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)
 {
  */
 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);
 }
 
   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 */
   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 =
 
   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();
     comm->start();

-    if (TRACE_is_enabled() && task->simdata->has_tracing_category())
+    if (TRACE_is_enabled() && task->has_tracing_category())

       simgrid::simix::simcall(
       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;
     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 */
       throw;
 
     /* If the send failed, it is not used anymore */

-    t_simdata->set_not_used();
+    task->set_not_used();

   }
 
   return ret;
   }
 
   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)
 {
  */
 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);
 }
 
   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();
 
 {
   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;

 }
 
 /**
 }
 
 /**


@@ -819,18 +811,17 @@ int MSG_task_listen_from(const char *alias)
  */
 void MSG_task_set_category (msg_task_t task, const char *category)
 {
  */
 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) {
 
   // 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
   } 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)
 {
  */
 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 3ad7c43..14384c6 100644 (file)
--- a/src/msg/msg_private.hpp
+++ b/src/msg/msg_private.hpp
@@ -7,9 +7,9 @@
 #define MSG_PRIVATE_HPP
 
 #include "simgrid/msg.h"
 #define MSG_PRIVATE_HPP
 
 #include "simgrid/msg.h"

-

 #include "src/kernel/activity/CommImpl.hpp"
 #include "src/kernel/activity/ExecImpl.hpp"
 #include "src/kernel/activity/CommImpl.hpp"
 #include "src/kernel/activity/ExecImpl.hpp"

+#include <simgrid/modelchecker.h>

 
 static long long int msg_task_max_counter = 0;
 
 
 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++;
       : 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; }
   }
   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 3bfa850..fd9544c 100644 (file)
--- a/src/msg/msg_task.cpp
+++ b/src/msg/msg_task.cpp
@@ -7,7 +7,6 @@
 #include "src/simix/smx_private.hpp"
 #include <algorithm>
 #include <cmath>
 #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)");
 #include <simgrid/s4u/Comm.hpp>
 
 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 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
 }
 
 /** @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);
   // 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 */
 
   /* 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) {
   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) {
   }
   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;
   }
 
   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)
 {
 /** @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)
 {
 }
 
 /** @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 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)
 {
 /** @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)
 {
 }
 
 /** @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)
 {
 }
 
 /** @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)
 {
 }
 
 /** @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.
 }
 
 /** @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)
 {
  */
 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 */
     /* 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;
   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");
 
 {
   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;
 }
 
   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");
 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
     // 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)
   } 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) {
  * 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)
   } 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)
 {
  */
 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.
 }
 
 /** @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)
 {
  */
 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
 }
 
 /** @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)
 {
  */
 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)
 {
 }
 
 /** @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.
 }
 
 /** @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)
 {
  */
 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).
 }
 
 /** @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).");
 {
   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;

 }
 }