Rename some activity/SynchroBlah into activity/BlahImpl (+clang-format)

diff --git a/src/kernel/activity/SynchroComm.cpp b/src/kernel/activity/CommImpl.cpp
similarity index 77%
rename from src/kernel/activity/SynchroComm.cpp
rename to src/kernel/activity/CommImpl.cpp
index 9cb4c37..aebf055 100644 (file)
--- a/src/kernel/activity/SynchroComm.cpp
+++ b/src/kernel/activity/CommImpl.cpp
@@ -1,26 +1,27 @@
-/* Copyright (c) 2007-2016. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved.          */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
-#include "src/kernel/activity/SynchroComm.hpp"
-#include "src/surf/surf_interface.hpp"
-#include "src/simix/smx_network_private.h"
+#include "src/kernel/activity/CommImpl.hpp"
+
 #include "simgrid/modelchecker.h"
 #include "src/mc/mc_replay.h"
+#include "src/simix/smx_network_private.h"
+#include "src/surf/surf_interface.hpp"
 
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_network);
 
-simgrid::kernel::activity::Comm::Comm(e_smx_comm_type_t _type) : type(_type)
+simgrid::kernel::activity::CommImpl::CommImpl(e_smx_comm_type_t _type) : type(_type)
 {
-  state = SIMIX_WAITING;
-  src_data=nullptr;
-  dst_data=nullptr;
+  state    = SIMIX_WAITING;
+  src_data = nullptr;
+  dst_data = nullptr;
   intrusive_ptr_add_ref(this);
   XBT_DEBUG("Create communicate synchro %p", this);
 }
 
-simgrid::kernel::activity::Comm::~Comm()
+simgrid::kernel::activity::CommImpl::~CommImpl()
 {
   XBT_DEBUG("Really free communication %p", this);
 
@@ -34,20 +35,19 @@ simgrid::kernel::activity::Comm::~Comm()
     src_buff = nullptr;
   }
 
-  if(mbox)
+  if (mbox)
     mbox->remove(this);
 }
 
-void simgrid::kernel::activity::Comm::suspend()
+void simgrid::kernel::activity::CommImpl::suspend()
 {
   /* FIXME: shall we suspend also the timeout synchro? */
   if (surf_comm)
     surf_comm->suspend();
   /* in the other case, the action will be suspended on creation, in SIMIX_comm_start() */
-
 }
 
-void simgrid::kernel::activity::Comm::resume()
+void simgrid::kernel::activity::CommImpl::resume()
 {
   /*FIXME: check what happen with the timeouts */
   if (surf_comm)
@@ -55,7 +55,7 @@ void simgrid::kernel::activity::Comm::resume()
   /* in the other case, the synchro were not really suspended yet, see SIMIX_comm_suspend() and SIMIX_comm_start() */
 }
 
-void simgrid::kernel::activity::Comm::cancel()
+void simgrid::kernel::activity::CommImpl::cancel()
 {
   /* if the synchro is a waiting state means that it is still in a mbox */
   /* so remove from it and delete it */
@@ -71,7 +71,7 @@ void simgrid::kernel::activity::Comm::cancel()
 }
 
 /**  @brief get the amount remaining from the communication */
-double simgrid::kernel::activity::Comm::remains()
+double simgrid::kernel::activity::CommImpl::remains()
 {
   if (state == SIMIX_RUNNING)
     return surf_comm->getRemains();
@@ -81,28 +81,28 @@ double simgrid::kernel::activity::Comm::remains()
 }
 
 /** @brief This is part of the cleanup process, probably an internal command */
-void simgrid::kernel::activity::Comm::cleanupSurf()
+void simgrid::kernel::activity::CommImpl::cleanupSurf()
 {
-  if (surf_comm){
+  if (surf_comm) {
     surf_comm->unref();
     surf_comm = nullptr;
   }
 
-  if (src_timeout){
+  if (src_timeout) {
     src_timeout->unref();
     src_timeout = nullptr;
   }
 
-  if (dst_timeout){
+  if (dst_timeout) {
     dst_timeout->unref();
     dst_timeout = nullptr;
   }
 }
 
-void simgrid::kernel::activity::Comm::post()
+void simgrid::kernel::activity::CommImpl::post()
 {
   /* Update synchro state */
-  if (src_timeout &&  src_timeout->getState() == simgrid::surf::Action::State::done)
+  if (src_timeout && src_timeout->getState() == simgrid::surf::Action::State::done)
     state = SIMIX_SRC_TIMEOUT;
   else if (dst_timeout && dst_timeout->getState() == simgrid::surf::Action::State::done)
     state = SIMIX_DST_TIMEOUT;
@@ -115,8 +115,8 @@ void simgrid::kernel::activity::Comm::post()
   } else
     state = SIMIX_DONE;
 
-  XBT_DEBUG("SIMIX_post_comm: comm %p, state %d, src_proc %p, dst_proc %p, detached: %d",
-            this, (int)state, src_proc, dst_proc, detached);
+  XBT_DEBUG("SIMIX_post_comm: comm %p, state %d, src_proc %p, dst_proc %p, detached: %d", this, (int)state, src_proc,
+            dst_proc, detached);
 
   /* destroy the surf actions associated with the Simix communication */
   cleanupSurf();

diff --git a/src/kernel/activity/CommImpl.hpp b/src/kernel/activity/CommImpl.hpp
index d1e1949..bbf350c 100644 (file)
--- a/src/kernel/activity/CommImpl.hpp
+++ b/src/kernel/activity/CommImpl.hpp
@@ -1,31 +1,70 @@
-/* Copyright (c) 2007-2016. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved.          */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
-#ifndef SRC_KERNEL_ACTIVITY_COMMIMPL_HPP_
-#define SRC_KERNEL_ACTIVITY_COMMIMPL_HPP_
+#ifndef SIMIX_SYNCHRO_COMM_HPP
+#define SIMIX_SYNCHRO_COMM_HPP
 
-#include "simgrid/forward.h"
+#include "src/kernel/activity/ActivityImpl.hpp"
+#include "surf/surf.h"
 
-#include <atomic>
-#include <simgrid/simix.hpp>
+typedef enum { SIMIX_COMM_SEND, SIMIX_COMM_RECEIVE, SIMIX_COMM_READY, SIMIX_COMM_DONE } e_smx_comm_type_t;
 
 namespace simgrid {
 namespace kernel {
 namespace activity {
 
-XBT_PUBLIC_CLASS CommImpl : ActivityImpl
+XBT_PUBLIC_CLASS CommImpl : public ActivityImpl
 {
+  ~CommImpl() override;
+
 public:
-  CommImpl() : piface_(this){};
-  ~CommImpl() = default;
+  explicit CommImpl(e_smx_comm_type_t type);
+  void suspend() override;
+  void resume() override;
+  void post() override;
+  void cancel();
+  double remains();
+  void cleanupSurf(); // FIXME: make me protected
+
+  e_smx_comm_type_t type;       /* Type of the communication (SIMIX_COMM_SEND or SIMIX_COMM_RECEIVE) */
+  smx_mailbox_t mbox = nullptr; /* Rendez-vous where the comm is queued */
+
+#if SIMGRID_HAVE_MC
+  smx_mailbox_t mbox_cpy = nullptr; /* Copy of the rendez-vous where the comm is queued, MC needs it for DPOR
+                                     (comm.mbox set to nullptr when the communication is removed from the mailbox
+                                     (used as garbage collector)) */
+#endif
+  bool detached = false; /* If detached or not */
+
+  void (*clean_fun)(void*) = nullptr; /* Function to clean the detached src_buf if something goes wrong */
+  int (*match_fun)(void*, void*, smx_activity_t) = nullptr; /* Filter function used by the other side. It is used when
+                                      looking if a given communication matches my needs. For that, myself must match the
+                                      expectations of the other side, too. See  */
+  void (*copy_data_fun)(smx_activity_t, void*, size_t) = nullptr;
 
-  using Ptr = boost::intrusive_ptr<ActivityImpl>;
-  simgrid::s4u::Comm piface_; // Our interface
+  /* Surf action data */
+  surf_action_t surf_comm   = nullptr; /* The Surf communication action encapsulated */
+  surf_action_t src_timeout = nullptr; /* Surf's actions to instrument the timeouts */
+  surf_action_t dst_timeout = nullptr; /* Surf's actions to instrument the timeouts */
+  smx_actor_t src_proc      = nullptr;
+  smx_actor_t dst_proc      = nullptr;
+  double rate               = 0.0;
+  double task_size          = 0.0;
+
+  /* Data to be transfered */
+  void* src_buff        = nullptr;
+  void* dst_buff        = nullptr;
+  size_t src_buff_size  = 0;
+  size_t* dst_buff_size = nullptr;
+  bool copied           = false; /* whether the data were already copied */
+
+  void* src_data = nullptr; /* User data associated to communication */
+  void* dst_data = nullptr;
 };
 }
 }
-}
+} // namespace simgrid::kernel::activity
 
-#endif /* SRC_KERNEL_ACTIVITY_COMMIMPL_HPP_ */
+#endif

diff --git a/src/kernel/activity/SynchroExec.cpp b/src/kernel/activity/ExecImpl.cpp
similarity index 68%
rename from src/kernel/activity/SynchroExec.cpp
rename to src/kernel/activity/ExecImpl.cpp
index 58af6ff..56c6436 100644 (file)
--- a/src/kernel/activity/SynchroExec.cpp
+++ b/src/kernel/activity/ExecImpl.cpp
@@ -5,42 +5,41 @@
 
 #include "simgrid/s4u/Host.hpp"
 
-#include "src/kernel/activity/SynchroExec.hpp"
-#include "src/surf/surf_interface.hpp"
+#include "src/kernel/activity/ExecImpl.hpp"
 #include "src/simix/smx_host_private.h"
+#include "src/surf/surf_interface.hpp"
 
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_process);
 
-simgrid::kernel::activity::Exec::Exec(const char*name, sg_host_t host) :
-    host_(host)
+simgrid::kernel::activity::ExecImpl::ExecImpl(const char* name, sg_host_t host) : host_(host)
 {
   if (name)
     this->name = name;
-  this->state = SIMIX_RUNNING;
+  this->state  = SIMIX_RUNNING;
 }
 
-simgrid::kernel::activity::Exec::~Exec()
+simgrid::kernel::activity::ExecImpl::~ExecImpl()
 {
   if (surf_exec)
     surf_exec->unref();
   if (timeoutDetector)
     timeoutDetector->unref();
 }
-void simgrid::kernel::activity::Exec::suspend()
+void simgrid::kernel::activity::ExecImpl::suspend()
 {
   XBT_VERB("This exec is suspended (remain: %f)", surf_exec->getRemains());
   if (surf_exec)
     surf_exec->suspend();
 }
 
-void simgrid::kernel::activity::Exec::resume()
+void simgrid::kernel::activity::ExecImpl::resume()
 {
   XBT_VERB("This exec is resumed (remain: %f)", surf_exec->getRemains());
   if (surf_exec)
     surf_exec->resume();
 }
 
-double simgrid::kernel::activity::Exec::remains()
+double simgrid::kernel::activity::ExecImpl::remains()
 {
   if (state == SIMIX_RUNNING)
     return surf_exec->getRemains();
@@ -48,11 +47,11 @@ double simgrid::kernel::activity::Exec::remains()
   return 0;
 }
 
-void simgrid::kernel::activity::Exec::post()
+void simgrid::kernel::activity::ExecImpl::post()
 {
-  if (host_ && host_->isOff()) {/* FIXME: handle resource failure for parallel tasks too */
-    /* If the host running the synchro failed, notice it. This way, the asking
-     * process can be killed if it runs on that host itself */
+  if (host_ && host_->isOff()) { /* FIXME: handle resource failure for parallel tasks too */
+                                 /* If the host running the synchro failed, notice it. This way, the asking
+                                  * process can be killed if it runs on that host itself */
     state = SIMIX_FAILED;
   } else if (surf_exec->getState() == simgrid::surf::Action::State::failed) {
     /* If the host running the synchro didn't fail, then the synchro was canceled */

diff --git a/src/kernel/activity/ExecImpl.hpp b/src/kernel/activity/ExecImpl.hpp
new file mode 100644 (file)
index 0000000..8012e39
--- /dev/null
+++ b/src/kernel/activity/ExecImpl.hpp
@@ -0,0 +1,36 @@
+/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved.          */
+
+/* This program is free software; you can redistribute it and/or modify it
+ * under the terms of the license (GNU LGPL) which comes with this package. */
+
+#ifndef SIMIX_SYNCHRO_EXEC_HPP
+#define SIMIX_SYNCHRO_EXEC_HPP
+
+#include "src/kernel/activity/ActivityImpl.hpp"
+#include "surf/surf.h"
+
+namespace simgrid {
+namespace kernel {
+namespace activity {
+
+XBT_PUBLIC_CLASS ExecImpl : public ActivityImpl
+{
+  ~ExecImpl() override;
+
+public:
+  ExecImpl(const char* name, sg_host_t host);
+  void suspend() override;
+  void resume() override;
+  void post() override;
+  double remains();
+
+  sg_host_t host_ =
+      nullptr; /* The host where the execution takes place. If nullptr, then this is a parallel exec (and only surf
+                  knows the hosts) */
+  surf_action_t surf_exec       = nullptr; /* The Surf execution action encapsulated */
+  surf::Action* timeoutDetector = nullptr;
+};
+}
+}
+} // namespace simgrid::kernel::activity
+#endif

diff --git a/src/kernel/activity/MailboxImpl.cpp b/src/kernel/activity/MailboxImpl.cpp
index 86b2e24..8c66d35 100644 (file)
--- a/src/kernel/activity/MailboxImpl.cpp
+++ b/src/kernel/activity/MailboxImpl.cpp
@@ -4,7 +4,8 @@
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
 #include "src/kernel/activity/MailboxImpl.hpp"
-#include "src/kernel/activity/SynchroComm.hpp"
+
+#include "src/kernel/activity/CommImpl.hpp"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_mailbox, simix, "Mailbox implementation");
 
@@ -52,7 +53,7 @@ void MailboxImpl::setReceiver(s4u::ActorPtr actor)
 /** @brief Pushes a communication activity into a mailbox
  *  @param comm What to add
  */
-void MailboxImpl::push(activity::Comm* comm)
+void MailboxImpl::push(activity::CommImpl* comm)
 {
   this->comm_queue.push_back(comm);
   comm->mbox = this;
@@ -63,7 +64,7 @@ void MailboxImpl::push(activity::Comm* comm)
  */
 void MailboxImpl::remove(smx_activity_t activity)
 {
-  simgrid::kernel::activity::Comm* comm = static_cast<simgrid::kernel::activity::Comm*>(activity);
+  simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(activity);
 
   comm->mbox = nullptr;
   for (auto it = this->comm_queue.begin(); it != this->comm_queue.end(); it++)

diff --git a/src/kernel/activity/MailboxImpl.hpp b/src/kernel/activity/MailboxImpl.hpp
index 2a2ec0d..ea9b272 100644 (file)
--- a/src/kernel/activity/MailboxImpl.hpp
+++ b/src/kernel/activity/MailboxImpl.hpp
@@ -9,7 +9,7 @@
 #include <boost/circular_buffer.hpp>
 
 #include "simgrid/s4u/Mailbox.hpp"
-#include "src/kernel/activity/SynchroComm.hpp"
+#include "src/kernel/activity/CommImpl.hpp"
 #include "src/simix/ActorImpl.hpp"
 
 #define MAX_MAILBOX_SIZE 10000000
@@ -31,7 +31,7 @@ public:
   static MailboxImpl* byNameOrNull(const char* name);
   static MailboxImpl* byNameOrCreate(const char* name);
   void setReceiver(s4u::ActorPtr actor);
-  void push(activity::Comm* comm);
+  void push(activity::CommImpl* comm);
   void remove(smx_activity_t activity);
   simgrid::s4u::Mailbox piface_; // Our interface
   char* name_;

diff --git a/src/kernel/activity/SynchroSleep.cpp b/src/kernel/activity/SleepImpl.cpp
similarity index 82%
rename from src/kernel/activity/SynchroSleep.cpp
rename to src/kernel/activity/SleepImpl.cpp
index 8143f7c..6db6d88 100644 (file)
--- a/src/kernel/activity/SynchroSleep.cpp
+++ b/src/kernel/activity/SleepImpl.cpp
@@ -5,36 +5,36 @@
 
 #include "simgrid/s4u/Host.hpp"
 
+#include "src/kernel/activity/SleepImpl.hpp"
 #include "src/kernel/context/Context.hpp"
-#include "src/kernel/activity/SynchroSleep.hpp"
 
-#include "src/surf/surf_interface.hpp"
 #include "src/simix/ActorImpl.hpp"
 #include "src/simix/popping_private.h"
+#include "src/surf/surf_interface.hpp"
 
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_process);
 
-void simgrid::kernel::activity::Sleep::suspend()
+void simgrid::kernel::activity::SleepImpl::suspend()
 {
   surf_sleep->suspend();
 }
 
-void simgrid::kernel::activity::Sleep::resume()
+void simgrid::kernel::activity::SleepImpl::resume()
 {
   surf_sleep->resume();
 }
 
-void simgrid::kernel::activity::Sleep::post()
+void simgrid::kernel::activity::SleepImpl::post()
 {
   while (not simcalls.empty()) {
     smx_simcall_t simcall = simcalls.front();
     simcalls.pop_front();
 
     e_smx_state_t state;
-    switch (surf_sleep->getState()){
+    switch (surf_sleep->getState()) {
       case simgrid::surf::Action::State::failed:
         simcall->issuer->context->iwannadie = 1;
-        //SMX_EXCEPTION(simcall->issuer, host_error, 0, "Host failed");
+        // SMX_EXCEPTION(simcall->issuer, host_error, 0, "Host failed");
         state = SIMIX_SRC_HOST_FAILURE;
         break;
 

diff --git a/src/kernel/activity/SynchroSleep.hpp b/src/kernel/activity/SleepImpl.hpp
similarity index 56%
rename from src/kernel/activity/SynchroSleep.hpp
rename to src/kernel/activity/SleepImpl.hpp
index aca0471..a149ce5 100644 (file)
--- a/src/kernel/activity/SynchroSleep.hpp
+++ b/src/kernel/activity/SleepImpl.hpp
@@ -6,23 +6,25 @@
 #ifndef SIMIX_SYNCHRO_SLEEP_HPP
 #define SIMIX_SYNCHRO_SLEEP_HPP
 
-#include "surf/surf.h"
 #include "src/kernel/activity/ActivityImpl.hpp"
+#include "surf/surf.h"
 
 namespace simgrid {
 namespace kernel {
 namespace activity {
 
-  XBT_PUBLIC_CLASS Sleep : public ActivityImpl {
-  public:
-    void suspend() override;
-    void resume() override;
-    void post() override;
-
-    sg_host_t host = nullptr;           /* The host that is sleeping */
-    surf_action_t surf_sleep = nullptr; /* The Surf sleeping action encapsulated */
-  };
-
-}}} // namespace simgrid::kernel::activity
+XBT_PUBLIC_CLASS SleepImpl : public ActivityImpl
+{
+public:
+  void suspend() override;
+  void resume() override;
+  void post() override;
+
+  sg_host_t host           = nullptr; /* The host that is sleeping */
+  surf_action_t surf_sleep = nullptr; /* The Surf sleeping action encapsulated */
+};
+}
+}
+} // namespace simgrid::kernel::activity
 
 #endif

diff --git a/src/kernel/activity/SynchroComm.hpp b/src/kernel/activity/SynchroComm.hpp
deleted file mode 100644 (file)
index b114b25..0000000
--- a/src/kernel/activity/SynchroComm.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved.          */
-
-/* This program is free software; you can redistribute it and/or modify it
- * under the terms of the license (GNU LGPL) which comes with this package. */
-
-#ifndef SIMIX_SYNCHRO_COMM_HPP
-#define SIMIX_SYNCHRO_COMM_HPP
-
-#include "surf/surf.h"
-#include "src/kernel/activity/ActivityImpl.hpp"
-
-typedef enum {
-  SIMIX_COMM_SEND,
-  SIMIX_COMM_RECEIVE,
-  SIMIX_COMM_READY,
-  SIMIX_COMM_DONE
-} e_smx_comm_type_t;
-
-namespace simgrid {
-namespace kernel {
-namespace activity {
-
-  XBT_PUBLIC_CLASS Comm : public ActivityImpl {
-    ~Comm() override;
-  public:
-    explicit Comm(e_smx_comm_type_t type);
-    void suspend() override;
-    void resume() override;
-    void post() override;
-    void cancel();
-    double remains();
-    void cleanupSurf(); // FIXME: make me protected
-
-    e_smx_comm_type_t type;         /* Type of the communication (SIMIX_COMM_SEND or SIMIX_COMM_RECEIVE) */
-    smx_mailbox_t mbox = nullptr;   /* Rendez-vous where the comm is queued */
-
-#if SIMGRID_HAVE_MC
-    smx_mailbox_t mbox_cpy = nullptr; /* Copy of the rendez-vous where the comm is queued, MC needs it for DPOR
-                                       (comm.mbox set to nullptr when the communication is removed from the mailbox
-                                       (used as garbage collector)) */
-#endif
-    bool detached = false;          /* If detached or not */
-
-    void (*clean_fun)(void*) = nullptr; /* Function to clean the detached src_buf if something goes wrong */
-    int (*match_fun)(void*,void*,smx_activity_t) = nullptr;  /* Filter function used by the other side. It is used when
-                                       looking if a given communication matches my needs. For that, myself must match the
-                                       expectations of the other side, too. See  */
-    void (*copy_data_fun) (smx_activity_t, void*, size_t) =nullptr;
-
-    /* Surf action data */
-    surf_action_t surf_comm = nullptr;        /* The Surf communication action encapsulated */
-    surf_action_t src_timeout = nullptr;      /* Surf's actions to instrument the timeouts */
-    surf_action_t dst_timeout = nullptr;      /* Surf's actions to instrument the timeouts */
-    smx_actor_t src_proc = nullptr;
-    smx_actor_t dst_proc = nullptr;
-    double rate = 0.0;
-    double task_size = 0.0;
-
-    /* Data to be transfered */
-    void *src_buff = nullptr;
-    void *dst_buff = nullptr;
-    size_t src_buff_size = 0;
-    size_t *dst_buff_size = nullptr;
-    bool copied = false;         /* whether the data were already copied */
-
-    void* src_data = nullptr;    /* User data associated to communication */
-    void* dst_data = nullptr;
-  };
-
-}}} // namespace simgrid::kernel::activity
-
-#endif

diff --git a/src/kernel/activity/SynchroExec.hpp b/src/kernel/activity/SynchroExec.hpp
deleted file mode 100644 (file)
index ad3e1fa..0000000
--- a/src/kernel/activity/SynchroExec.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved.          */
-
-/* This program is free software; you can redistribute it and/or modify it
- * under the terms of the license (GNU LGPL) which comes with this package. */
-
-#ifndef SIMIX_SYNCHRO_EXEC_HPP
-#define SIMIX_SYNCHRO_EXEC_HPP
-
-#include "surf/surf.h"
-#include "src/kernel/activity/ActivityImpl.hpp"
-
-namespace simgrid {
-namespace kernel {
-namespace activity {
-
-  XBT_PUBLIC_CLASS Exec : public ActivityImpl {
-    ~Exec() override;
-  public:
-    Exec(const char*name, sg_host_t host);
-    void suspend() override;
-    void resume() override;
-    void post() override;
-    double remains();
-
-    sg_host_t host_ = nullptr; /* The host where the execution takes place. If nullptr, then this is a parallel exec (and only surf knows the hosts) */
-    surf_action_t surf_exec = nullptr; /* The Surf execution action encapsulated */
-    surf::Action* timeoutDetector = nullptr;
-  };
-
-}}} // namespace simgrid::kernel::activity
-#endif

diff --git a/src/mc/checker/CommunicationDeterminismChecker.cpp b/src/mc/checker/CommunicationDeterminismChecker.cpp
index a98f55b..15d1ccd 100644 (file)
--- a/src/mc/checker/CommunicationDeterminismChecker.cpp
+++ b/src/mc/checker/CommunicationDeterminismChecker.cpp
@@ -96,12 +96,12 @@ static char* print_determinism_result(e_mc_comm_pattern_difference_t diff, int p
 }
 
 static void update_comm_pattern(simgrid::mc::PatternCommunication* comm_pattern,
-                                simgrid::mc::RemotePtr<simgrid::kernel::activity::Comm> comm_addr)
+                                simgrid::mc::RemotePtr<simgrid::kernel::activity::CommImpl> comm_addr)
 {
   // HACK, type punning
-  simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_comm;
+  simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_comm;
   mc_model_checker->process().read(temp_comm, comm_addr);
-  simgrid::kernel::activity::Comm* comm = temp_comm.getBuffer();
+  simgrid::kernel::activity::CommImpl* comm = temp_comm.getBuffer();
 
   smx_actor_t src_proc   = mc_model_checker->process().resolveActor(simgrid::mc::remote(comm->src_proc));
   smx_actor_t dst_proc   = mc_model_checker->process().resolveActor(simgrid::mc::remote(comm->dst_proc));
@@ -187,10 +187,11 @@ void CommunicationDeterminismChecker::get_comm_pattern(xbt_dynar_t list, smx_sim
     pattern->type = simgrid::mc::PatternCommunicationType::send;
     pattern->comm_addr = simcall_comm_isend__get__result(request);
 
-    simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_synchro;
+    simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_synchro;
     mc_model_checker->process().read(temp_synchro,
-                                     remote(static_cast<simgrid::kernel::activity::Comm*>(pattern->comm_addr)));
-    simgrid::kernel::activity::Comm* synchro = static_cast<simgrid::kernel::activity::Comm*>(temp_synchro.getBuffer());
+                                     remote(static_cast<simgrid::kernel::activity::CommImpl*>(pattern->comm_addr)));
+    simgrid::kernel::activity::CommImpl* synchro =
+        static_cast<simgrid::kernel::activity::CommImpl*>(temp_synchro.getBuffer());
 
     char* remote_name = mc_model_checker->process().read<char*>(
         (std::uint64_t)(synchro->mbox ? &synchro->mbox->name_ : &synchro->mbox_cpy->name_));
@@ -229,10 +230,10 @@ void CommunicationDeterminismChecker::get_comm_pattern(xbt_dynar_t list, smx_sim
                                      remote((simgrid::smpi::Request*)simcall_comm_irecv__get__data(request)));
     pattern->tag = mpi_request.tag();
 
-    simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_comm;
+    simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_comm;
     mc_model_checker->process().read(temp_comm,
-                                     remote(static_cast<simgrid::kernel::activity::Comm*>(pattern->comm_addr)));
-    simgrid::kernel::activity::Comm* comm = temp_comm.getBuffer();
+                                     remote(static_cast<simgrid::kernel::activity::CommImpl*>(pattern->comm_addr)));
+    simgrid::kernel::activity::CommImpl* comm = temp_comm.getBuffer();
 
     char* remote_name;
     mc_model_checker->process().read(&remote_name, remote(comm->mbox ? &comm->mbox->name_ : &comm->mbox_cpy->name_));
@@ -249,7 +250,7 @@ void CommunicationDeterminismChecker::get_comm_pattern(xbt_dynar_t list, smx_sim
 }
 
 void CommunicationDeterminismChecker::complete_comm_pattern(
-    xbt_dynar_t list, simgrid::mc::RemotePtr<simgrid::kernel::activity::Comm> comm_addr, unsigned int issuer,
+    xbt_dynar_t list, simgrid::mc::RemotePtr<simgrid::kernel::activity::CommImpl> comm_addr, unsigned int issuer,
     int backtracking)
 {
   simgrid::mc::PatternCommunication* current_comm_pattern;

diff --git a/src/mc/checker/CommunicationDeterminismChecker.hpp b/src/mc/checker/CommunicationDeterminismChecker.hpp
index d185c90..f14abb1 100644 (file)
--- a/src/mc/checker/CommunicationDeterminismChecker.hpp
+++ b/src/mc/checker/CommunicationDeterminismChecker.hpp
@@ -36,9 +36,9 @@ private:
 public:
   // These are used by functions which should be moved in CommunicationDeterminismChecker:
   void get_comm_pattern(xbt_dynar_t list, smx_simcall_t request, e_mc_call_type_t call_type, int backtracking);
-  void complete_comm_pattern(
-    xbt_dynar_t list, simgrid::mc::RemotePtr<simgrid::kernel::activity::Comm> comm_addr,
-    unsigned int issuer, int backtracking);
+  void complete_comm_pattern(xbt_dynar_t list, simgrid::mc::RemotePtr<simgrid::kernel::activity::CommImpl> comm_addr,
+                             unsigned int issuer, int backtracking);
+
 private:
   /** Stack representing the position in the exploration graph */
   std::list<std::unique_ptr<simgrid::mc::State>> stack_;

diff --git a/src/mc/mc_base.cpp b/src/mc/mc_base.cpp
index 8933c4e..ee5098e 100644 (file)
--- a/src/mc/mc_base.cpp
+++ b/src/mc/mc_base.cpp
@@ -78,16 +78,16 @@ bool request_is_enabled(smx_simcall_t req)
   case SIMCALL_COMM_WAIT:
   {
     /* FIXME: check also that src and dst processes are not suspended */
-    simgrid::kernel::activity::Comm *act =
-        static_cast<simgrid::kernel::activity::Comm*>(simcall_comm_wait__get__comm(req));
+    simgrid::kernel::activity::CommImpl* act =
+        static_cast<simgrid::kernel::activity::CommImpl*>(simcall_comm_wait__get__comm(req));
 
 #if SIMGRID_HAVE_MC
     // Fetch from MCed memory:
     // HACK, type puning
     if (mc_model_checker != nullptr) {
-      simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_comm;
+      simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_comm;
       mc_model_checker->process().read(temp_comm, remote(act));
-      act = static_cast<simgrid::kernel::activity::Comm*>(temp_comm.getBuffer());
+      act = static_cast<simgrid::kernel::activity::CommImpl*>(temp_comm.getBuffer());
     }
 #endif
 
@@ -106,8 +106,8 @@ bool request_is_enabled(smx_simcall_t req)
 
   case SIMCALL_COMM_WAITANY: {
     xbt_dynar_t comms;
-    simgrid::kernel::activity::Comm *act =
-        static_cast<simgrid::kernel::activity::Comm*>(simcall_comm_wait__get__comm(req));
+    simgrid::kernel::activity::CommImpl* act =
+        static_cast<simgrid::kernel::activity::CommImpl*>(simcall_comm_wait__get__comm(req));
 
 #if SIMGRID_HAVE_MC
     s_xbt_dynar_t comms_buffer;
@@ -135,15 +135,15 @@ bool request_is_enabled(smx_simcall_t req)
 #if SIMGRID_HAVE_MC
       // Fetch act from MCed memory:
       // HACK, type puning
-      simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_comm;
+      simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_comm;
       if (mc_model_checker != nullptr) {
         memcpy(&act, buffer + comms->elmsize * index, sizeof(act));
         mc_model_checker->process().read(temp_comm, remote(act));
-        act = static_cast<simgrid::kernel::activity::Comm*>(temp_comm.getBuffer());
+        act = static_cast<simgrid::kernel::activity::CommImpl*>(temp_comm.getBuffer());
       }
       else
 #endif
-        act = xbt_dynar_get_as(comms, index, simgrid::kernel::activity::Comm*);
+        act = xbt_dynar_get_as(comms, index, simgrid::kernel::activity::CommImpl*);
       if (act->src_proc && act->dst_proc)
         return true;
     }

diff --git a/src/mc/mc_comm_pattern.cpp b/src/mc/mc_comm_pattern.cpp
index cc1aa14..c6eede3 100644 (file)
--- a/src/mc/mc_comm_pattern.cpp
+++ b/src/mc/mc_comm_pattern.cpp
@@ -86,16 +86,15 @@ void MC_handle_comm_pattern(
   case MC_CALL_TYPE_WAIT:
   case MC_CALL_TYPE_WAITANY:
     {
-      simgrid::mc::RemotePtr<simgrid::kernel::activity::Comm> comm_addr = nullptr;
-      if (call_type == MC_CALL_TYPE_WAIT)
-        comm_addr = remote(static_cast<simgrid::kernel::activity::Comm*>(
-          simcall_comm_wait__get__comm(req)));
-      else {
-        simgrid::kernel::activity::Comm* addr;
-        // comm_addr = REMOTE(xbt_dynar_get_as(simcall_comm_waitany__get__comms(req), value, smx_synchro_t)):
-        simgrid::mc::read_element(mc_model_checker->process(), &addr,
-          remote(simcall_comm_waitany__get__comms(req)), value, sizeof(comm_addr));
-        comm_addr = remote(addr);
+    simgrid::mc::RemotePtr<simgrid::kernel::activity::CommImpl> comm_addr = nullptr;
+    if (call_type == MC_CALL_TYPE_WAIT)
+      comm_addr = remote(static_cast<simgrid::kernel::activity::CommImpl*>(simcall_comm_wait__get__comm(req)));
+    else {
+      simgrid::kernel::activity::CommImpl* addr;
+      // comm_addr = REMOTE(xbt_dynar_get_as(simcall_comm_waitany__get__comms(req), value, smx_synchro_t)):
+      simgrid::mc::read_element(mc_model_checker->process(), &addr, remote(simcall_comm_waitany__get__comms(req)),
+                                value, sizeof(comm_addr));
+      comm_addr = remote(addr);
       }
       checker->complete_comm_pattern(pattern, comm_addr,
         MC_smx_simcall_get_issuer(req)->pid, backtracking);

diff --git a/src/mc/mc_request.cpp b/src/mc/mc_request.cpp
index 261360d..06e09a4 100644 (file)
--- a/src/mc/mc_request.cpp
+++ b/src/mc/mc_request.cpp
@@ -19,14 +19,13 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_request, mc,
 static char *pointer_to_string(void *pointer);
 static char *buff_size_to_string(size_t size);
 
-static inline
-simgrid::kernel::activity::Comm* MC_get_comm(smx_simcall_t r)
+static inline simgrid::kernel::activity::CommImpl* MC_get_comm(smx_simcall_t r)
 {
   switch (r->call ) {
   case SIMCALL_COMM_WAIT:
-    return static_cast<simgrid::kernel::activity::Comm*>(simcall_comm_wait__get__comm(r));
+    return static_cast<simgrid::kernel::activity::CommImpl*>(simcall_comm_wait__get__comm(r));
   case SIMCALL_COMM_TEST:
-    return static_cast<simgrid::kernel::activity::Comm*>(simcall_comm_test__get__comm(r));
+    return static_cast<simgrid::kernel::activity::CommImpl*>(simcall_comm_test__get__comm(r));
   default:
     return nullptr;
   }
@@ -60,8 +59,8 @@ bool request_depend_asymmetric(smx_simcall_t r1, smx_simcall_t r2)
 
   // Those are internal requests, we do not need indirection
   // because those objects are copies:
-  simgrid::kernel::activity::Comm* synchro1 = MC_get_comm(r1);
-  simgrid::kernel::activity::Comm* synchro2 = MC_get_comm(r2);
+  simgrid::kernel::activity::CommImpl* synchro1 = MC_get_comm(r1);
+  simgrid::kernel::activity::CommImpl* synchro2 = MC_get_comm(r2);
 
   if ((r1->call == SIMCALL_COMM_ISEND || r1->call == SIMCALL_COMM_IRECV)
       && r2->call == SIMCALL_COMM_WAIT) {
@@ -147,8 +146,8 @@ bool request_depend(smx_simcall_t r1, smx_simcall_t r2)
 
   // Those are internal requests, we do not need indirection
   // because those objects are copies:
-  simgrid::kernel::activity::Comm* synchro1 = MC_get_comm(r1);
-  simgrid::kernel::activity::Comm* synchro2 = MC_get_comm(r2);
+  simgrid::kernel::activity::CommImpl* synchro1 = MC_get_comm(r1);
+  simgrid::kernel::activity::CommImpl* synchro2 = MC_get_comm(r2);
 
   switch(r1->call) {
   case SIMCALL_COMM_ISEND:
@@ -257,8 +256,8 @@ std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid
   }
 
   case SIMCALL_COMM_WAIT: {
-    simgrid::kernel::activity::Comm* remote_act =
-      static_cast<simgrid::kernel::activity::Comm*>(simcall_comm_wait__get__comm(req));
+    simgrid::kernel::activity::CommImpl* remote_act =
+        static_cast<simgrid::kernel::activity::CommImpl*>(simcall_comm_wait__get__comm(req));
     char* p;
     if (value == -1) {
       type = "WaitTimeout";
@@ -268,11 +267,11 @@ std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid
       type = "Wait";
       p = pointer_to_string(remote_act);
 
-      simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_synchro;
-      simgrid::kernel::activity::Comm* act;
+      simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_synchro;
+      simgrid::kernel::activity::CommImpl* act;
       if (use_remote_comm) {
-        mc_model_checker->process().read(temp_synchro, remote(
-          static_cast<simgrid::kernel::activity::Comm*>(remote_act)));
+        mc_model_checker->process().read(temp_synchro,
+                                         remote(static_cast<simgrid::kernel::activity::CommImpl*>(remote_act)));
         act = temp_synchro.getBuffer();
       } else
         act = remote_act;
@@ -290,13 +289,13 @@ std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid
   }
 
   case SIMCALL_COMM_TEST: {
-    simgrid::kernel::activity::Comm* remote_act = static_cast<simgrid::kernel::activity::Comm*>(
-      simcall_comm_test__get__comm(req));
-    simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_synchro;
-    simgrid::kernel::activity::Comm* act;
+    simgrid::kernel::activity::CommImpl* remote_act =
+        static_cast<simgrid::kernel::activity::CommImpl*>(simcall_comm_test__get__comm(req));
+    simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_synchro;
+    simgrid::kernel::activity::CommImpl* act;
     if (use_remote_comm) {
-      mc_model_checker->process().read(temp_synchro, remote(
-        static_cast<simgrid::kernel::activity::Comm*>(remote_act)));
+      mc_model_checker->process().read(temp_synchro,
+                                       remote(static_cast<simgrid::kernel::activity::CommImpl*>(remote_act)));
       act = temp_synchro.getBuffer();
     } else
       act = remote_act;
@@ -430,10 +429,9 @@ bool request_is_enabled_by_idx(smx_simcall_t req, unsigned int idx)
     return true;
   }
 
-  simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_comm;
-  mc_model_checker->process().read(temp_comm, remote(
-    static_cast<simgrid::kernel::activity::Comm*>(remote_act)));
-  simgrid::kernel::activity::Comm* comm = temp_comm.getBuffer();
+  simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_comm;
+  mc_model_checker->process().read(temp_comm, remote(static_cast<simgrid::kernel::activity::CommImpl*>(remote_act)));
+  simgrid::kernel::activity::CommImpl* comm = temp_comm.getBuffer();
   return comm->src_proc && comm->dst_proc;
 }
 
@@ -492,10 +490,10 @@ std::string request_get_dot_output(smx_simcall_t req, int value)
         label = simgrid::xbt::string_printf("[(%lu)] WaitTimeout", issuer->pid);
     } else {
       smx_activity_t remote_act = simcall_comm_wait__get__comm(req);
-      simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_comm;
-      mc_model_checker->process().read(temp_comm, remote(
-        static_cast<simgrid::kernel::activity::Comm*>(remote_act)));
-      simgrid::kernel::activity::Comm* comm = temp_comm.getBuffer();
+      simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_comm;
+      mc_model_checker->process().read(temp_comm,
+                                       remote(static_cast<simgrid::kernel::activity::CommImpl*>(remote_act)));
+      simgrid::kernel::activity::CommImpl* comm = temp_comm.getBuffer();
 
       smx_actor_t src_proc = mc_model_checker->process().resolveActor(simgrid::mc::remote(comm->src_proc));
       smx_actor_t dst_proc = mc_model_checker->process().resolveActor(simgrid::mc::remote(comm->dst_proc));
@@ -514,10 +512,9 @@ std::string request_get_dot_output(smx_simcall_t req, int value)
 
   case SIMCALL_COMM_TEST: {
     smx_activity_t remote_act = simcall_comm_test__get__comm(req);
-    simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_comm;
-    mc_model_checker->process().read(temp_comm, remote(
-      static_cast<simgrid::kernel::activity::Comm*>(remote_act)));
-    simgrid::kernel::activity::Comm* comm = temp_comm.getBuffer();
+    simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_comm;
+    mc_model_checker->process().read(temp_comm, remote(static_cast<simgrid::kernel::activity::CommImpl*>(remote_act)));
+    simgrid::kernel::activity::CommImpl* comm = temp_comm.getBuffer();
     if (comm->src_proc == nullptr || comm->dst_proc == nullptr) {
       if (issuer->host)
         label = simgrid::xbt::string_printf("[(%lu)%s] Test FALSE", issuer->pid, MC_smx_actor_get_host_name(issuer));

diff --git a/src/mc/mc_state.cpp b/src/mc/mc_state.cpp
index 9d041d7..e399fa2 100644 (file)
--- a/src/mc/mc_state.cpp
+++ b/src/mc/mc_state.cpp
@@ -129,11 +129,11 @@ static inline smx_simcall_t MC_state_get_request_for_process(
       }
 
       case SIMCALL_COMM_WAIT: {
-        simgrid::mc::RemotePtr<simgrid::kernel::activity::Comm> remote_act = remote(
-          static_cast<simgrid::kernel::activity::Comm*>(simcall_comm_wait__get__comm(&actor->simcall)));
-        simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_act;
+        simgrid::mc::RemotePtr<simgrid::kernel::activity::CommImpl> remote_act =
+            remote(static_cast<simgrid::kernel::activity::CommImpl*>(simcall_comm_wait__get__comm(&actor->simcall)));
+        simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_act;
         mc_model_checker->process().read(temp_act, remote_act);
-        simgrid::kernel::activity::Comm* act = temp_act.getBuffer();
+        simgrid::kernel::activity::CommImpl* act = temp_act.getBuffer();
         if (act->src_proc && act->dst_proc)
           state->transition.argument = 0;
         else if (act->src_proc == nullptr && act->type == SIMIX_COMM_READY
@@ -180,8 +180,8 @@ static inline smx_simcall_t MC_state_get_request_for_process(
     read_element(mc_model_checker->process(),
       &remote_comm, remote(simcall_comm_waitany__get__comms(req)),
       state->transition.argument, sizeof(remote_comm));
-    mc_model_checker->process().read(state->internal_comm, remote(
-      static_cast<simgrid::kernel::activity::Comm*>(remote_comm)));
+    mc_model_checker->process().read(state->internal_comm,
+                                     remote(static_cast<simgrid::kernel::activity::CommImpl*>(remote_comm)));
     simcall_comm_wait__set__comm(&state->internal_req, state->internal_comm.getBuffer());
     simcall_comm_wait__set__timeout(&state->internal_req, 0);
     break;
@@ -193,8 +193,8 @@ static inline smx_simcall_t MC_state_get_request_for_process(
     if (state->transition.argument > 0) {
       smx_activity_t remote_comm = mc_model_checker->process().read(
         remote(simcall_comm_testany__get__comms(req) + state->transition.argument));
-      mc_model_checker->process().read(state->internal_comm, remote(
-        static_cast<simgrid::kernel::activity::Comm*>(remote_comm)));
+      mc_model_checker->process().read(state->internal_comm,
+                                       remote(static_cast<simgrid::kernel::activity::CommImpl*>(remote_comm)));
     }
 
     simcall_comm_test__set__comm(&state->internal_req, state->internal_comm.getBuffer());

diff --git a/src/mc/mc_state.h b/src/mc/mc_state.h
index 1e65beb..d807e28 100644 (file)
--- a/src/mc/mc_state.h
+++ b/src/mc/mc_state.h
@@ -125,7 +125,7 @@ struct XBT_PRIVATE State {
   s_smx_simcall_t internal_req;
 
   /* Can be used as a copy of the remote synchro object */
-  simgrid::mc::Remote<simgrid::kernel::activity::Comm> internal_comm;
+  simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> internal_comm;
 
   /** Snapshot of system state (if needed) */
   std::shared_ptr<simgrid::mc::Snapshot> system_state;

diff --git a/src/msg/msg_gos.cpp b/src/msg/msg_gos.cpp
index 8e921e3..3f416bc 100644 (file)
--- a/src/msg/msg_gos.cpp
+++ b/src/msg/msg_gos.cpp
@@ -66,12 +66,12 @@ msg_error_t MSG_parallel_task_execute_with_timeout(msg_task_t task, double timeo
     simdata->setUsed();
 
     if (simdata->host_nb > 0) {
-      simdata->compute = static_cast<simgrid::kernel::activity::Exec*>(simcall_execution_parallel_start(
+      simdata->compute = static_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, -1.0, timeout));
       XBT_DEBUG("Parallel execution action created: %p", simdata->compute);
     } else {
-      simdata->compute = static_cast<simgrid::kernel::activity::Exec*>(
+      simdata->compute = static_cast<simgrid::kernel::activity::ExecImpl*>(
           simcall_execution_start(task->name, simdata->flops_amount, simdata->priority, simdata->bound));
     }
     simcall_set_category(simdata->compute, task->category);
@@ -316,7 +316,7 @@ static inline msg_comm_t MSG_task_isend_internal(msg_task_t task, const char *al
   /* Send it by calling SIMIX network layer */
   smx_activity_t act = simcall_comm_isend(myself->getImpl(), mailbox->getImpl(), t_simdata->bytes_amount, t_simdata->rate,
                                          task, sizeof(void *), match_fun, cleanup, nullptr, match_data,detached);
-  t_simdata->comm = static_cast<simgrid::kernel::activity::Comm*>(act);
+  t_simdata->comm = static_cast<simgrid::kernel::activity::CommImpl*>(act);
 
   msg_comm_t comm = nullptr;
   if (not detached) {
@@ -711,7 +711,7 @@ msg_task_t MSG_comm_get_task(msg_comm_t comm)
  */
 void MSG_comm_copy_data_from_SIMIX(smx_activity_t synchro, void* buff, size_t buff_size)
 {
-  simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
+  simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
 
   SIMIX_comm_copy_pointer_callback(comm, buff, buff_size);
 
@@ -798,9 +798,9 @@ msg_error_t MSG_task_send_with_timeout(msg_task_t task, const char *alias, doubl
                               t_simdata->rate, task, sizeof(void *), nullptr, nullptr, nullptr, task, 0);
     if (TRACE_is_enabled())
       simcall_set_category(comm, task->category);
-     t_simdata->comm = static_cast<simgrid::kernel::activity::Comm*>(comm);
-     simcall_comm_wait(comm, timeout);
-     SIMIX_comm_unref(comm);
+    t_simdata->comm = static_cast<simgrid::kernel::activity::CommImpl*>(comm);
+    simcall_comm_wait(comm, timeout);
+    SIMIX_comm_unref(comm);
   }
   catch (xbt_ex& e) {
     switch (e.category) {
@@ -869,7 +869,7 @@ int MSG_task_listen(const char *alias)
 int MSG_task_listen_from(const char *alias)
 {
   simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::byName(alias);
-  simgrid::kernel::activity::Comm* comm = static_cast<simgrid::kernel::activity::Comm*>(mbox->front());
+  simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(mbox->front());
 
   if (not comm)
     return -1;

diff --git a/src/msg/msg_private.h b/src/msg/msg_private.h
index 1e39918..d83517b 100644 (file)
--- a/src/msg/msg_private.h
+++ b/src/msg/msg_private.h
@@ -8,10 +8,9 @@
 
 #include "simgrid/msg.h"
 
-#include "src/kernel/activity/SynchroExec.hpp"
-#include "src/kernel/activity/SynchroComm.hpp"
-
-#include <xbt/Extendable.hpp>
+#include "src/kernel/activity/CommImpl.hpp"
+#include "src/kernel/activity/ExecImpl.hpp"
+#include "xbt/Extendable.hpp"
 
 /**************** datatypes **********************************/
 /**************************** Host Extension *********************************/
@@ -43,8 +42,8 @@ typedef struct simdata_task {
     this->isused = false;
   }
 
-  simgrid::kernel::activity::Exec *compute = nullptr; /* SIMIX modeling of computation */
-  simgrid::kernel::activity::Comm *comm = nullptr;    /* SIMIX modeling of communication */
+  simgrid::kernel::activity::ExecImpl* compute = nullptr; /* SIMIX modeling of computation */
+  simgrid::kernel::activity::CommImpl* comm = nullptr; /* SIMIX modeling of communication */
   double bytes_amount = 0.0; /* Data size */
   double flops_amount = 0.0; /* Computation size */
   msg_process_t sender = nullptr;

diff --git a/src/s4u/s4u_comm.cpp b/src/s4u/s4u_comm.cpp
index da54cdd..801e9b5 100644 (file)
--- a/src/s4u/s4u_comm.cpp
+++ b/src/s4u/s4u_comm.cpp
@@ -175,7 +175,7 @@ s4u::CommPtr Comm::recv_async(MailboxPtr dest, void** data)
 
 void Comm::cancel()
 {
-  simgrid::kernel::activity::Comm* commPimpl = static_cast<simgrid::kernel::activity::Comm*>(pimpl_);
+  simgrid::kernel::activity::CommImpl* commPimpl = static_cast<simgrid::kernel::activity::CommImpl*>(pimpl_);
   commPimpl->cancel();
 }
 bool Comm::test() {

diff --git a/src/simix/ActorImpl.cpp b/src/simix/ActorImpl.cpp
index eda8077..2930fc1 100644 (file)
--- a/src/simix/ActorImpl.cpp
+++ b/src/simix/ActorImpl.cpp
@@ -10,20 +10,20 @@
 
 #include <boost/range/algorithm.hpp>
 
-#include <xbt/functional.hpp>
-#include <xbt/ex.hpp>
-#include <xbt/sysdep.h>
-#include <xbt/log.h>
-#include <xbt/dict.h>
+#include "xbt/dict.h"
+#include "xbt/ex.hpp"
+#include "xbt/functional.hpp"
+#include "xbt/log.h"
+#include "xbt/sysdep.h"
 
 #include "simgrid/s4u/Host.hpp"
 
-#include <mc/mc.h>
+#include "mc/mc.h"
 
 #include "smx_private.h"
+#include "src/kernel/activity/SleepImpl.hpp"
 #include "src/kernel/activity/SynchroIo.hpp"
 #include "src/kernel/activity/SynchroRaw.hpp"
-#include "src/kernel/activity/SynchroSleep.hpp"
 #include "src/mc/mc_replay.h"
 #include "src/mc/remote/Client.hpp"
 #include "src/msg/msg_private.h"
@@ -96,7 +96,7 @@ void SIMIX_process_cleanup(smx_actor_t process)
   /* cancel non-blocking communications */
   smx_activity_t synchro = static_cast<smx_activity_t>(process->comms.front());
   while (not process->comms.empty()) {
-    simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
+    simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
 
     /* make sure no one will finish the comm after this process is destroyed,
      * because src_proc or dst_proc would be an invalid pointer */
@@ -425,9 +425,12 @@ void SIMIX_process_kill(smx_actor_t process, smx_actor_t issuer) {
   /* destroy the blocking synchro if any */
   if (process->waiting_synchro) {
 
-    simgrid::kernel::activity::Exec *exec = dynamic_cast<simgrid::kernel::activity::Exec*>(process->waiting_synchro);
-    simgrid::kernel::activity::Comm *comm = dynamic_cast<simgrid::kernel::activity::Comm*>(process->waiting_synchro);
-    simgrid::kernel::activity::Sleep *sleep = dynamic_cast<simgrid::kernel::activity::Sleep*>(process->waiting_synchro);
+    simgrid::kernel::activity::ExecImpl* exec =
+        dynamic_cast<simgrid::kernel::activity::ExecImpl*>(process->waiting_synchro);
+    simgrid::kernel::activity::CommImpl* comm =
+        dynamic_cast<simgrid::kernel::activity::CommImpl*>(process->waiting_synchro);
+    simgrid::kernel::activity::SleepImpl* sleep =
+        dynamic_cast<simgrid::kernel::activity::SleepImpl*>(process->waiting_synchro);
     simgrid::kernel::activity::Raw *raw = dynamic_cast<simgrid::kernel::activity::Raw*>(process->waiting_synchro);
     simgrid::kernel::activity::Io *io = dynamic_cast<simgrid::kernel::activity::Io*>(process->waiting_synchro);
 
@@ -484,18 +487,21 @@ void SIMIX_process_throw(smx_actor_t process, xbt_errcat_t cat, int value, const
   /* cancel the blocking synchro if any */
   if (process->waiting_synchro) {
 
-    simgrid::kernel::activity::Exec *exec = dynamic_cast<simgrid::kernel::activity::Exec*>(process->waiting_synchro);
+    simgrid::kernel::activity::ExecImpl* exec =
+        dynamic_cast<simgrid::kernel::activity::ExecImpl*>(process->waiting_synchro);
     if (exec != nullptr) {
       SIMIX_execution_cancel(process->waiting_synchro);
     }
 
-    simgrid::kernel::activity::Comm *comm = dynamic_cast<simgrid::kernel::activity::Comm*>(process->waiting_synchro);
+    simgrid::kernel::activity::CommImpl* comm =
+        dynamic_cast<simgrid::kernel::activity::CommImpl*>(process->waiting_synchro);
     if (comm != nullptr) {
       process->comms.remove(comm);
       comm->cancel();
     }
 
-    simgrid::kernel::activity::Sleep *sleep = dynamic_cast<simgrid::kernel::activity::Sleep*>(process->waiting_synchro);
+    simgrid::kernel::activity::SleepImpl* sleep =
+        dynamic_cast<simgrid::kernel::activity::SleepImpl*>(process->waiting_synchro);
     if (sleep != nullptr) {
       SIMIX_process_sleep_destroy(process->waiting_synchro);
       if (not xbt_dynar_member(simix_global->process_to_run, &(process)) && process != SIMIX_process_self()) {
@@ -691,7 +697,7 @@ void simcall_HANDLER_process_join(smx_simcall_t simcall, smx_actor_t process, do
 }
 
 static int SIMIX_process_join_finish(smx_process_exit_status_t status, smx_activity_t synchro){
-  simgrid::kernel::activity::Sleep *sleep = static_cast<simgrid::kernel::activity::Sleep*>(synchro);
+  simgrid::kernel::activity::SleepImpl* sleep = static_cast<simgrid::kernel::activity::SleepImpl*>(synchro);
 
   if (sleep->surf_sleep) {
     sleep->surf_sleep->cancel();
@@ -751,7 +757,7 @@ smx_activity_t SIMIX_process_sleep(smx_actor_t process, double duration)
   if (host->isOff())
     THROWF(host_error, 0, "Host %s failed, you cannot sleep there.", host->cname());
 
-  simgrid::kernel::activity::Sleep *synchro = new simgrid::kernel::activity::Sleep();
+  simgrid::kernel::activity::SleepImpl* synchro = new simgrid::kernel::activity::SleepImpl();
   synchro->host = host;
   synchro->surf_sleep                       = host->pimpl_cpu->sleep(duration);
   synchro->surf_sleep->setData(synchro);
@@ -763,7 +769,7 @@ smx_activity_t SIMIX_process_sleep(smx_actor_t process, double duration)
 void SIMIX_process_sleep_destroy(smx_activity_t synchro)
 {
   XBT_DEBUG("Destroy synchro %p", synchro);
-  simgrid::kernel::activity::Sleep *sleep = static_cast<simgrid::kernel::activity::Sleep*>(synchro);
+  simgrid::kernel::activity::SleepImpl* sleep = static_cast<simgrid::kernel::activity::SleepImpl*>(synchro);
 
   if (sleep->surf_sleep) {
     sleep->surf_sleep->unref();

diff --git a/src/simix/libsmx.cpp b/src/simix/libsmx.cpp
index ccf2f8c..a3aad4a 100644 (file)
--- a/src/simix/libsmx.cpp
+++ b/src/simix/libsmx.cpp
@@ -15,21 +15,18 @@
 
 #include <functional>
 
-#include <xbt/functional.hpp>
-
-#include <simgrid/s4u/VirtualMachine.hpp>
-#include <simgrid/simix/blocking_simcall.hpp>
-
 #include "mc/mc.h"
+#include "simgrid/s4u/VirtualMachine.hpp"
+#include "simgrid/simix.hpp"
+#include "simgrid/simix/blocking_simcall.hpp"
 #include "smx_private.h"
-#include "src/kernel/activity/SynchroComm.hpp"
+#include "src/kernel/activity/CommImpl.hpp"
 #include "src/mc/mc_forward.hpp"
 #include "src/mc/mc_replay.h"
 #include "src/plugins/vm/VirtualMachineImpl.hpp"
 #include "src/simix/smx_host_private.h"
 #include "xbt/ex.h"
-
-#include <simgrid/simix.hpp>
+#include "xbt/functional.hpp"
 
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix);
 
@@ -461,8 +458,8 @@ smx_activity_t simcall_comm_iprobe(smx_mailbox_t mbox, int type, int src, int ta
  */
 void simcall_comm_cancel(smx_activity_t synchro)
 {
-  simgrid::simix::kernelImmediate([synchro]{
-    simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
+  simgrid::simix::kernelImmediate([synchro] {
+    simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
     comm->cancel();
   });
 }

diff --git a/src/simix/popping.cpp b/src/simix/popping.cpp
index 5a6957d..396969d 100644 (file)
--- a/src/simix/popping.cpp
+++ b/src/simix/popping.cpp
@@ -1,5 +1,4 @@
-/* Copyright (c) 2010-2015. The SimGrid Team.
- * All rights reserved.                                                     */
+/* Copyright (c) 2010-2017. The SimGrid Team. All rights reserved.          */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
@@ -10,11 +9,11 @@
 #include "src/mc/mc_private.h"
 #endif
 
-#include "src/kernel/activity/SynchroExec.hpp"
-#include "src/kernel/activity/SynchroComm.hpp"
-#include "src/kernel/activity/SynchroSleep.hpp"
-#include "src/kernel/activity/SynchroRaw.hpp"
+#include "src/kernel/activity/CommImpl.hpp"
+#include "src/kernel/activity/ExecImpl.hpp"
+#include "src/kernel/activity/SleepImpl.hpp"
 #include "src/kernel/activity/SynchroIo.hpp"
+#include "src/kernel/activity/SynchroRaw.hpp"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_popping, simix,
                                 "Popping part of SIMIX (transmuting from user request into kernel handlers)");

diff --git a/src/simix/smx_global.cpp b/src/simix/smx_global.cpp
index 47184cb..a3c309a 100644 (file)
--- a/src/simix/smx_global.cpp
+++ b/src/simix/smx_global.cpp
@@ -27,9 +27,9 @@
 
 #include "src/smpi/smpi_process.hpp"
 
-#include "src/kernel/activity/SynchroExec.hpp"
-#include "src/kernel/activity/SynchroComm.hpp"
-#include "src/kernel/activity/SynchroSleep.hpp"
+#include "src/kernel/activity/CommImpl.hpp"
+#include "src/kernel/activity/ExecImpl.hpp"
+#include "src/kernel/activity/SleepImpl.hpp"
 #include "src/kernel/activity/SynchroIo.hpp"
 #include "src/kernel/activity/SynchroRaw.hpp"
 
@@ -654,13 +654,13 @@ void SIMIX_display_process_status()
 
       const char* synchro_description = "unknown";
 
-      if (dynamic_cast<simgrid::kernel::activity::Exec*>(process->waiting_synchro) != nullptr)
+      if (dynamic_cast<simgrid::kernel::activity::ExecImpl*>(process->waiting_synchro) != nullptr)
         synchro_description = "execution";
 
-      if (dynamic_cast<simgrid::kernel::activity::Comm*>(process->waiting_synchro) != nullptr)
+      if (dynamic_cast<simgrid::kernel::activity::CommImpl*>(process->waiting_synchro) != nullptr)
         synchro_description = "communication";
 
-      if (dynamic_cast<simgrid::kernel::activity::Sleep*>(process->waiting_synchro) != nullptr)
+      if (dynamic_cast<simgrid::kernel::activity::SleepImpl*>(process->waiting_synchro) != nullptr)
         synchro_description = "sleeping";
 
       if (dynamic_cast<simgrid::kernel::activity::Raw*>(process->waiting_synchro) != nullptr)

diff --git a/src/simix/smx_host.cpp b/src/simix/smx_host.cpp
index 11e3235..e459249 100644 (file)
--- a/src/simix/smx_host.cpp
+++ b/src/simix/smx_host.cpp
@@ -5,11 +5,10 @@
 
 #include "mc/mc.h"
 #include "smx_private.h"
+#include "src/kernel/activity/CommImpl.hpp"
 #include "src/mc/mc_replay.h"
 #include "src/plugins/vm/VirtualMachineImpl.hpp"
-#include <xbt/ex.hpp>
-
-#include "src/kernel/activity/SynchroComm.hpp"
+#include "xbt/ex.hpp"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_host, simix, "SIMIX hosts");
 
@@ -162,7 +161,7 @@ smx_activity_t SIMIX_execution_start(smx_actor_t issuer, const char *name, doubl
                                     double bound){
 
   /* alloc structures and initialize */
-  simgrid::kernel::activity::Exec *exec = new simgrid::kernel::activity::Exec(name, issuer->host);
+  simgrid::kernel::activity::ExecImpl* exec = new simgrid::kernel::activity::ExecImpl(name, issuer->host);
 
   /* set surf's action */
   if (not MC_is_active() && not MC_record_replay_is_active()) {
@@ -185,7 +184,7 @@ smx_activity_t SIMIX_execution_parallel_start(const char* name, int host_nb, sg_
 {
 
   /* alloc structures and initialize */
-  simgrid::kernel::activity::Exec *exec = new simgrid::kernel::activity::Exec(name, nullptr);
+  simgrid::kernel::activity::ExecImpl* exec = new simgrid::kernel::activity::ExecImpl(name, nullptr);
 
   /* set surf's synchro */
   sg_host_t *host_list_cpy = xbt_new0(sg_host_t, host_nb);
@@ -216,7 +215,7 @@ smx_activity_t SIMIX_execution_parallel_start(const char* name, int host_nb, sg_
 void SIMIX_execution_cancel(smx_activity_t synchro)
 {
   XBT_DEBUG("Cancel synchro %p", synchro);
-  simgrid::kernel::activity::Exec *exec = static_cast<simgrid::kernel::activity::Exec *>(synchro);
+  simgrid::kernel::activity::ExecImpl* exec = static_cast<simgrid::kernel::activity::ExecImpl*>(synchro);
 
   if (exec->surf_exec)
     exec->surf_exec->cancel();
@@ -224,21 +223,21 @@ void SIMIX_execution_cancel(smx_activity_t synchro)
 
 void SIMIX_execution_set_priority(smx_activity_t synchro, double priority)
 {
-  simgrid::kernel::activity::Exec *exec = static_cast<simgrid::kernel::activity::Exec *>(synchro);
+  simgrid::kernel::activity::ExecImpl* exec = static_cast<simgrid::kernel::activity::ExecImpl*>(synchro);
   if(exec->surf_exec)
     exec->surf_exec->setPriority(priority);
 }
 
 void SIMIX_execution_set_bound(smx_activity_t synchro, double bound)
 {
-  simgrid::kernel::activity::Exec *exec = static_cast<simgrid::kernel::activity::Exec *>(synchro);
+  simgrid::kernel::activity::ExecImpl* exec = static_cast<simgrid::kernel::activity::ExecImpl*>(synchro);
   if(exec->surf_exec)
     static_cast<simgrid::surf::CpuAction*>(exec->surf_exec)->setBound(bound);
 }
 
 void simcall_HANDLER_execution_wait(smx_simcall_t simcall, smx_activity_t synchro)
 {
-  simgrid::kernel::activity::Exec *exec = static_cast<simgrid::kernel::activity::Exec *>(synchro);
+  simgrid::kernel::activity::ExecImpl* exec = static_cast<simgrid::kernel::activity::ExecImpl*>(synchro);
   XBT_DEBUG("Wait for execution of synchro %p, state %d", synchro, (int)synchro->state);
 
   /* Associate this simcall to the synchro */
@@ -257,7 +256,7 @@ void simcall_HANDLER_execution_wait(smx_simcall_t simcall, smx_activity_t synchr
     SIMIX_execution_finish(exec);
 }
 
-void SIMIX_execution_finish(simgrid::kernel::activity::Exec *exec)
+void SIMIX_execution_finish(simgrid::kernel::activity::ExecImpl* exec)
 {
   for (smx_simcall_t simcall : exec->simcalls) {
     switch (exec->state) {
@@ -305,13 +304,13 @@ void SIMIX_set_category(smx_activity_t synchro, const char *category)
   if (synchro->state != SIMIX_RUNNING)
     return;
 
-  simgrid::kernel::activity::Exec *exec = dynamic_cast<simgrid::kernel::activity::Exec *>(synchro);
+  simgrid::kernel::activity::ExecImpl* exec = dynamic_cast<simgrid::kernel::activity::ExecImpl*>(synchro);
   if (exec != nullptr) {
     exec->surf_exec->setCategory(category);
     return;
   }
 
-  simgrid::kernel::activity::Comm *comm = dynamic_cast<simgrid::kernel::activity::Comm *>(synchro);
+  simgrid::kernel::activity::CommImpl* comm = dynamic_cast<simgrid::kernel::activity::CommImpl*>(synchro);
   if (comm != nullptr) {
     comm->surf_comm->setCategory(category);
   }

diff --git a/src/simix/smx_host_private.h b/src/simix/smx_host_private.h
index 3db24e8..91149d1 100644 (file)
--- a/src/simix/smx_host_private.h
+++ b/src/simix/smx_host_private.h
@@ -15,7 +15,7 @@
 #include "simgrid/simix.h"
 #include "popping_private.h"
 
-#include "src/kernel/activity/SynchroExec.hpp"
+#include "src/kernel/activity/ExecImpl.hpp"
 
 /** @brief Host datatype from SIMIX POV */
 namespace simgrid {
@@ -57,7 +57,7 @@ XBT_PRIVATE void SIMIX_execution_cancel(smx_activity_t synchro);
 XBT_PRIVATE void SIMIX_execution_set_priority(smx_activity_t synchro, double priority);
 XBT_PRIVATE void SIMIX_execution_set_bound(smx_activity_t synchro, double bound);
 
-XBT_PRIVATE void SIMIX_execution_finish(simgrid::kernel::activity::Exec *exec);
+XBT_PRIVATE void SIMIX_execution_finish(simgrid::kernel::activity::ExecImpl* exec);
 
 XBT_PRIVATE void SIMIX_set_category(smx_activity_t synchro, const char *category);
 

diff --git a/src/simix/smx_network.cpp b/src/simix/smx_network.cpp
index 209902c..d709632 100644 (file)
--- a/src/simix/smx_network.cpp
+++ b/src/simix/smx_network.cpp
@@ -7,6 +7,7 @@
 
 #include <boost/range/algorithm.hpp>
 
+#include "src/kernel/activity/CommImpl.hpp"
 #include <xbt/ex.hpp>
 
 #include "simgrid/s4u/Host.hpp"
@@ -19,7 +20,6 @@
 #include "src/surf/cpu_interface.hpp"
 #include "src/surf/surf_interface.hpp"
 
-#include "src/kernel/activity/SynchroComm.hpp"
 #include "src/surf/network_interface.hpp"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_network, simix, "SIMIX network-related synchronization");
@@ -27,7 +27,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_network, simix, "SIMIX network-related syn
 static void SIMIX_waitany_remove_simcall_from_actions(smx_simcall_t simcall);
 static void SIMIX_comm_copy_data(smx_activity_t comm);
 static void SIMIX_comm_start(smx_activity_t synchro);
-static simgrid::kernel::activity::Comm*
+static simgrid::kernel::activity::CommImpl*
 _find_matching_comm(boost::circular_buffer_space_optimized<smx_activity_t>* deque, e_smx_comm_type_t type,
                     int (*match_fun)(void*, void*, smx_activity_t), void* user_data, smx_activity_t my_synchro,
                     bool remove_matching);
@@ -37,7 +37,7 @@ _find_matching_comm(boost::circular_buffer_space_optimized<smx_activity_t>* dequ
  *  \param type The type of communication we are looking for (comm_send, comm_recv)
  *  \return The communication activity if found, nullptr otherwise
  */
-static simgrid::kernel::activity::Comm*
+static simgrid::kernel::activity::CommImpl*
 _find_matching_comm(boost::circular_buffer_space_optimized<smx_activity_t>* deque, e_smx_comm_type_t type,
                     int (*match_fun)(void*, void*, smx_activity_t), void* this_user_data, smx_activity_t my_synchro,
                     bool remove_matching)
@@ -46,7 +46,7 @@ _find_matching_comm(boost::circular_buffer_space_optimized<smx_activity_t>* dequ
 
   for(auto it = deque->begin(); it != deque->end(); it++){
     smx_activity_t synchro = *it;
-    simgrid::kernel::activity::Comm* comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
+    simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
 
     if (comm->type == SIMIX_COMM_SEND) {
       other_user_data = comm->src_data;
@@ -58,7 +58,7 @@ _find_matching_comm(boost::circular_buffer_space_optimized<smx_activity_t>* dequ
       XBT_DEBUG("Found a matching communication synchro %p", comm);
       if (remove_matching)
         deque->erase(it);
-      comm = static_cast<simgrid::kernel::activity::Comm*>(SIMIX_comm_ref(comm));
+      comm = static_cast<simgrid::kernel::activity::CommImpl*>(SIMIX_comm_ref(comm));
 #if SIMGRID_HAVE_MC
       comm->mbox_cpy = comm->mbox;
 #endif
@@ -99,13 +99,13 @@ XBT_PRIVATE smx_activity_t simcall_HANDLER_comm_isend(smx_simcall_t simcall, smx
   XBT_DEBUG("send from %p", mbox);
 
   /* Prepare a synchro describing us, so that it gets passed to the user-provided filter of other side */
-  simgrid::kernel::activity::Comm* this_comm = new simgrid::kernel::activity::Comm(SIMIX_COMM_SEND);
+  simgrid::kernel::activity::CommImpl* this_comm = new simgrid::kernel::activity::CommImpl(SIMIX_COMM_SEND);
 
   /* Look for communication synchro matching our needs. We also provide a description of
    * ourself so that the other side also gets a chance of choosing if it wants to match with us.
    *
    * If it is not found then push our communication into the rendez-vous point */
-  simgrid::kernel::activity::Comm* other_comm =
+  simgrid::kernel::activity::CommImpl* other_comm =
       _find_matching_comm(&mbox->comm_queue, SIMIX_COMM_RECEIVE, match_fun, data, this_comm, /*remove_matching*/ true);
 
   if (not other_comm) {
@@ -115,7 +115,7 @@ XBT_PRIVATE smx_activity_t simcall_HANDLER_comm_isend(smx_simcall_t simcall, smx
       //this mailbox is for small messages, which have to be sent right now
       other_comm->state   = SIMIX_READY;
       other_comm->dst_proc=mbox->permanent_receiver.get();
-      other_comm          = static_cast<simgrid::kernel::activity::Comm*>(SIMIX_comm_ref(other_comm));
+      other_comm          = static_cast<simgrid::kernel::activity::CommImpl*>(SIMIX_comm_ref(other_comm));
       mbox->done_comm_queue.push_back(other_comm);
       XBT_DEBUG("pushing a message into the permanent receive list %p, comm %p", mbox, &(other_comm));
 
@@ -185,10 +185,10 @@ smx_activity_t SIMIX_comm_irecv(smx_actor_t dst_proc, smx_mailbox_t mbox, void *
     void (*copy_data_fun)(smx_activity_t, void*, size_t), // used to copy data if not default one
     void *data, double rate)
 {
-  simgrid::kernel::activity::Comm* this_synchro = new simgrid::kernel::activity::Comm(SIMIX_COMM_RECEIVE);
+  simgrid::kernel::activity::CommImpl* this_synchro = new simgrid::kernel::activity::CommImpl(SIMIX_COMM_RECEIVE);
   XBT_DEBUG("recv from %p %p. this_synchro=%p", mbox, &mbox->comm_queue, this_synchro);
 
-  simgrid::kernel::activity::Comm* other_comm;
+  simgrid::kernel::activity::CommImpl* other_comm;
   //communication already done, get it inside the list of completed comms
   if (mbox->permanent_receiver != nullptr && not mbox->done_comm_queue.empty()) {
 
@@ -227,7 +227,7 @@ smx_activity_t SIMIX_comm_irecv(smx_actor_t dst_proc, smx_mailbox_t mbox, void *
       mbox->push(this_synchro);
     } else {
       SIMIX_comm_unref(this_synchro);
-      other_comm = static_cast<simgrid::kernel::activity::Comm*>(other_comm);
+      other_comm = static_cast<simgrid::kernel::activity::CommImpl*>(other_comm);
 
       other_comm->state = SIMIX_READY;
       other_comm->type = SIMIX_COMM_READY;
@@ -267,13 +267,13 @@ smx_activity_t SIMIX_comm_iprobe(smx_actor_t dst_proc, smx_mailbox_t mbox, int t
                               int tag, int (*match_fun)(void *, void *, smx_activity_t), void *data)
 {
   XBT_DEBUG("iprobe from %p %p", mbox, &mbox->comm_queue);
-  simgrid::kernel::activity::Comm* this_comm;
+  simgrid::kernel::activity::CommImpl* this_comm;
   int smx_type;
   if(type == 1){
-    this_comm = new simgrid::kernel::activity::Comm(SIMIX_COMM_SEND);
+    this_comm = new simgrid::kernel::activity::CommImpl(SIMIX_COMM_SEND);
     smx_type = SIMIX_COMM_RECEIVE;
   } else{
-    this_comm = new simgrid::kernel::activity::Comm(SIMIX_COMM_RECEIVE);
+    this_comm = new simgrid::kernel::activity::CommImpl(SIMIX_COMM_RECEIVE);
     smx_type = SIMIX_COMM_SEND;
   } 
   smx_activity_t other_synchro=nullptr;
@@ -313,7 +313,7 @@ void simcall_HANDLER_comm_wait(smx_simcall_t simcall, smx_activity_t synchro, do
       if (timeout < 0.0)
         THROW_IMPOSSIBLE;
 
-      simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
+      simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
       if (comm->src_proc == simcall->issuer)
         comm->state = SIMIX_SRC_TIMEOUT;
       else
@@ -332,7 +332,7 @@ void simcall_HANDLER_comm_wait(smx_simcall_t simcall, smx_activity_t synchro, do
     surf_action_t sleep = simcall->issuer->host->pimpl_cpu->sleep(timeout);
     sleep->setData(synchro);
 
-    simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
+    simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
     if (simcall->issuer == comm->src_proc)
       comm->src_timeout = sleep;
     else
@@ -342,7 +342,7 @@ void simcall_HANDLER_comm_wait(smx_simcall_t simcall, smx_activity_t synchro, do
 
 void simcall_HANDLER_comm_test(smx_simcall_t simcall, smx_activity_t synchro)
 {
-  simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
+  simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
 
   if (MC_is_active() || MC_record_replay_is_active()){
     simcall_comm_test__set__result(simcall, comm->src_proc && comm->dst_proc);
@@ -457,7 +457,7 @@ void SIMIX_waitany_remove_simcall_from_actions(smx_simcall_t simcall)
  */
 static inline void SIMIX_comm_start(smx_activity_t synchro)
 {
-  simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
+  simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
 
   /* If both the sender and the receiver are already there, start the communication */
   if (synchro->state == SIMIX_READY) {
@@ -502,7 +502,7 @@ static inline void SIMIX_comm_start(smx_activity_t synchro)
  */
 void SIMIX_comm_finish(smx_activity_t synchro)
 {
-  simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
+  simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
 
   while (not synchro->simcalls.empty()) {
     smx_simcall_t simcall = synchro->simcalls.front();
@@ -660,7 +660,7 @@ void SIMIX_comm_set_copy_data_callback(void (*callback) (smx_activity_t, void*,
 
 void SIMIX_comm_copy_pointer_callback(smx_activity_t synchro, void* buff, size_t buff_size)
 {
-  simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
+  simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
 
   xbt_assert((buff_size == sizeof(void *)), "Cannot copy %zu bytes: must be sizeof(void*)", buff_size);
   *(void **) (comm->dst_buff) = buff;
@@ -668,7 +668,7 @@ void SIMIX_comm_copy_pointer_callback(smx_activity_t synchro, void* buff, size_t
 
 void SIMIX_comm_copy_buffer_callback(smx_activity_t synchro, void* buff, size_t buff_size)
 {
-  simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
+  simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
 
   XBT_DEBUG("Copy the data over");
   memcpy(comm->dst_buff, buff, buff_size);
@@ -684,7 +684,7 @@ void SIMIX_comm_copy_buffer_callback(smx_activity_t synchro, void* buff, size_t
  */
 void SIMIX_comm_copy_data(smx_activity_t synchro)
 {
-  simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
+  simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
 
   size_t buff_size = comm->src_buff_size;
   /* If there is no data to copy then return */

diff --git a/src/smpi/smpi_global.cpp b/src/smpi/smpi_global.cpp
index d45a4a0..687e972 100644 (file)
--- a/src/smpi/smpi_global.cpp
+++ b/src/smpi/smpi_global.cpp
@@ -144,7 +144,7 @@ static void check_blocks(std::vector<std::pair<size_t, size_t>> &private_blocks,
 
 void smpi_comm_copy_buffer_callback(smx_activity_t synchro, void *buff, size_t buff_size)
 {
-  simgrid::kernel::activity::Comm *comm = dynamic_cast<simgrid::kernel::activity::Comm*>(synchro);
+  simgrid::kernel::activity::CommImpl* comm = dynamic_cast<simgrid::kernel::activity::CommImpl*>(synchro);
   int src_shared                        = 0;
   int dst_shared                        = 0;
   size_t src_offset                     = 0;

diff --git a/src/smpi/smpi_request.cpp b/src/smpi/smpi_request.cpp
index 733ae20..e839534 100644 (file)
--- a/src/smpi/smpi_request.cpp
+++ b/src/smpi/smpi_request.cpp
@@ -3,16 +3,17 @@
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
+#include "src/smpi/smpi_request.hpp"
+
 #include "mc/mc.h"
+#include "src/kernel/activity/CommImpl.hpp"
 #include "src/mc/mc_replay.h"
 #include "src/smpi/SmpiHost.hpp"
-#include "src/kernel/activity/SynchroComm.hpp"
 #include "src/smpi/private.h"
 #include "src/smpi/smpi_comm.hpp"
 #include "src/smpi/smpi_datatype.hpp"
 #include "src/smpi/smpi_op.hpp"
 #include "src/smpi/smpi_process.hpp"
-#include "src/smpi/smpi_request.hpp"
 
 #include <algorithm>
 
@@ -651,7 +652,8 @@ void Request::iprobe(int source, int tag, MPI_Comm comm, int* flag, MPI_Status*
   }
 
   if (request->action_ != nullptr){
-    simgrid::kernel::activity::Comm *sync_comm = static_cast<simgrid::kernel::activity::Comm*>(request->action_);
+    simgrid::kernel::activity::CommImpl* sync_comm =
+        static_cast<simgrid::kernel::activity::CommImpl*>(request->action_);
     MPI_Request req                            = static_cast<MPI_Request>(sync_comm->src_data);
     *flag = 1;
     if(status != MPI_STATUS_IGNORE && (req->flags_ & PREPARED) == 0) {

diff --git a/src/smpi/smpi_request.hpp b/src/smpi/smpi_request.hpp
index f9c8446..96d1cf8 100644 (file)
--- a/src/smpi/smpi_request.hpp
+++ b/src/smpi/smpi_request.hpp
@@ -1,5 +1,4 @@
-/* Copyright (c) 2010, 2013-2017. The SimGrid Team.
- * All rights reserved.                                                     */
+/* Copyright (c) 2010-2017. The SimGrid Team. All rights reserved.          */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
@@ -7,6 +6,7 @@
 #ifndef SMPI_REQUEST_HPP_INCLUDED
 #define SMPI_REQUEST_HPP_INCLUDED
 
+#include "smpi/smpi.h"
 #include "src/smpi/smpi_f2c.hpp"
 
 namespace simgrid{

diff --git a/tools/cmake/DefinePackages.cmake b/tools/cmake/DefinePackages.cmake
index 88f03a6..1226d70 100644 (file)
--- a/tools/cmake/DefinePackages.cmake
+++ b/tools/cmake/DefinePackages.cmake
@@ -30,13 +30,6 @@ set(EXTRA_DIST
   src/simix/smx_network_private.h
   src/simix/smx_private.h
   src/simix/smx_synchro_private.h
-  src/kernel/activity/ActivityImpl.hpp
-  src/kernel/activity/CommImpl.hpp
-  src/kernel/activity/SynchroComm.hpp
-  src/kernel/activity/SynchroExec.hpp
-  src/kernel/activity/SynchroIo.hpp
-  src/kernel/activity/SynchroSleep.hpp
-  src/kernel/activity/SynchroRaw.hpp
   src/smpi/colls/coll_tuned_topo.h
   src/smpi/colls/colls_private.h
   src/smpi/colls/smpi_mvapich2_selector_stampede.h
@@ -385,13 +378,19 @@ set(SIMIX_SRC
   src/simix/smx_synchro.cpp
   src/simix/popping.cpp
   src/kernel/activity/ActivityImpl.cpp
+  src/kernel/activity/ActivityImpl.hpp
+  src/kernel/activity/CommImpl.cpp
+  src/kernel/activity/CommImpl.hpp
+  src/kernel/activity/ExecImpl.cpp
+  src/kernel/activity/ExecImpl.hpp
   src/kernel/activity/MailboxImpl.cpp
   src/kernel/activity/MailboxImpl.hpp
-  src/kernel/activity/SynchroComm.cpp
-  src/kernel/activity/SynchroExec.cpp
-  src/kernel/activity/SynchroSleep.cpp
-  src/kernel/activity/SynchroRaw.cpp
+  src/kernel/activity/SleepImpl.cpp
+  src/kernel/activity/SleepImpl.hpp
   src/kernel/activity/SynchroIo.cpp
+  src/kernel/activity/SynchroIo.hpp
+  src/kernel/activity/SynchroRaw.cpp
+  src/kernel/activity/SynchroRaw.hpp
   
   ${SIMIX_GENERATED_SRC}
   )