Allow to chain calls to activity::Comm functions

(and the same for Exec and Io activities)

We want to write something like:

  CommPtr comm = mailbox->put_async(data, 8)->set_rate(0);

Before, all these functions were returning an Activity* in the hope of
allowing such chaining, but it was failing, as most of these functions
only exist in Comm, not in Activity. This commit improves this.

It also opens a Pandora box. The method
   Activity* Activity::start()
is now overriden by the method
   Comm* Comm::start()
. (Comm is a subclass of Activity)

I believe that changing the return type to a subclass is OK when
overriding a method, but I'm not 100% sure. At least, both GCC and
clang seem OK with that code.

diff --git a/include/simgrid/s4u/Comm.hpp b/include/simgrid/s4u/Comm.hpp
index c9016f9..1b36069 100644 (file)
--- a/include/simgrid/s4u/Comm.hpp
+++ b/include/simgrid/s4u/Comm.hpp
@@ -42,22 +42,22 @@ public:
   /*! take a vector s4u::CommPtr and return the rank of the first finished one (or -1 if none is done). */
   static int test_any(std::vector<CommPtr> * comms);
 
   /*! take a vector s4u::CommPtr and return the rank of the first finished one (or -1 if none is done). */
   static int test_any(std::vector<CommPtr> * comms);
 

-  Activity* start() override;
-  Activity* wait() override;
-  Activity* wait_for(double timeout) override;
+  Comm* start() override;
+  Comm* wait() override;
+  Comm* wait_for(double timeout) override;

   bool test() override;
 
   /** Start the comm, and ignore its result. It can be completely forgotten after that. */
   bool test() override;
 
   /** Start the comm, and ignore its result. It can be completely forgotten after that. */

-  Activity* detach();
+  Comm* detach();

   /** Start the comm, and ignore its result. It can be completely forgotten after that. */
   /** Start the comm, and ignore its result. It can be completely forgotten after that. */

-  Activity* detach(void (*clean_function)(void*))
+  Comm* detach(void (*clean_function)(void*))

   {
     clean_fun_ = clean_function;
     return detach();
   }
 
   /** Sets the maximal communication rate (in byte/sec). Must be done before start */
   {
     clean_fun_ = clean_function;
     return detach();
   }
 
   /** Sets the maximal communication rate (in byte/sec). Must be done before start */

-  Activity* set_rate(double rate);
+  Comm* set_rate(double rate);

 
   /** Specify the data to send.
    *
 
   /** Specify the data to send.
    *


@@ -66,7 +66,7 @@ public:
    * you can send a short buffer in your simulator, that represents a very large message
    * in the simulated world, or the opposite.
    */
    * you can send a short buffer in your simulator, that represents a very large message
    * in the simulated world, or the opposite.
    */

-  Activity* set_src_data(void* buff);
+  Comm* set_src_data(void* buff);

   /** Specify the size of the data to send. Not to be mixed with @ref Activity::set_remaining()
    *
    * That's the size of the data to actually copy in the simulator (ie, the data passed with Activity::set_src_data()).
   /** Specify the size of the data to send. Not to be mixed with @ref Activity::set_remaining()
    *
    * That's the size of the data to actually copy in the simulator (ie, the data passed with Activity::set_src_data()).


@@ -74,7 +74,7 @@ public:
    * you can send a short buffer in your simulator, that represents a very large message
    * in the simulated world, or the opposite.
    */
    * you can send a short buffer in your simulator, that represents a very large message
    * in the simulated world, or the opposite.
    */

-  Activity* set_src_data_size(size_t size);
+  Comm* set_src_data_size(size_t size);

   /** Specify the data to send and its size. Don't mix the size with @ref Activity::set_remaining()
    *
    * This is way will get actually copied over to the receiver.
   /** Specify the data to send and its size. Don't mix the size with @ref Activity::set_remaining()
    *
    * This is way will get actually copied over to the receiver.


@@ -82,20 +82,20 @@ public:
    * you can send a short buffer in your simulator, that represents a very large message
    * in the simulated world, or the opposite.
    */
    * you can send a short buffer in your simulator, that represents a very large message
    * in the simulated world, or the opposite.
    */

-  Activity* set_src_data(void* buff, size_t size);
+  Comm* set_src_data(void* buff, size_t size);

 
   /** Specify where to receive the data.
    *
    * That's a buffer where the sent data will be copied */
 
   /** Specify where to receive the data.
    *
    * That's a buffer where the sent data will be copied */

-  Activity* set_dst_data(void** buff);
+  Comm* set_dst_data(void** buff);

   /** Specify the buffer in which the data should be received
    *
    * That's a buffer where the sent data will be copied  */
   /** Specify the buffer in which the data should be received
    *
    * That's a buffer where the sent data will be copied  */

-  Activity* set_dst_data(void** buff, size_t size);
+  Comm* set_dst_data(void** buff, size_t size);

   /** Retrieve the size of the received data. Not to be mixed with @ref Activity::set_remaining()  */
   size_t get_dst_data_size();
 
   /** Retrieve the size of the received data. Not to be mixed with @ref Activity::set_remaining()  */
   size_t get_dst_data_size();
 

-  Activity* cancel() override;
+  Comm* cancel() override;

 
   /** Retrieve the mailbox on which this comm acts */
   MailboxPtr get_mailbox();
 
   /** Retrieve the mailbox on which this comm acts */
   MailboxPtr get_mailbox();

diff --git a/include/simgrid/s4u/Exec.hpp b/include/simgrid/s4u/Exec.hpp
index 18f0028..9045404 100644 (file)
--- a/include/simgrid/s4u/Exec.hpp
+++ b/include/simgrid/s4u/Exec.hpp
@@ -31,10 +31,10 @@ public:
   static simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> on_start;
   static simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> on_completion;
 
   static simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> on_start;
   static simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> on_completion;
 

-  Activity* start() override;
-  Activity* wait() override;
-  Activity* wait_for(double timeout) override;
-  Activity* cancel() override;
+  Exec* start() override;
+  Exec* wait() override;
+  Exec* wait_for(double timeout) override;
+  Exec* cancel() override;

   bool test() override;
 
   ExecPtr set_priority(double priority);
   bool test() override;
 
   ExecPtr set_priority(double priority);

diff --git a/include/simgrid/s4u/Io.hpp b/include/simgrid/s4u/Io.hpp
index 2fb16f1..4e7ae31 100644 (file)
--- a/include/simgrid/s4u/Io.hpp
+++ b/include/simgrid/s4u/Io.hpp
@@ -33,10 +33,10 @@ public:
 
   ~Io() = default;
 
 
   ~Io() = default;
 

-  Activity* start() override;
-  Activity* wait() override;
-  Activity* wait_for(double timeout) override;
-  Activity* cancel() override;
+  Io* start() override;
+  Io* wait() override;
+  Io* wait_for(double timeout) override;
+  Io* cancel() override;

   bool test() override;
 
   double get_remaining() override;
   bool test() override;
 
   double get_remaining() override;

diff --git a/src/s4u/s4u_Comm.cpp b/src/s4u/s4u_Comm.cpp
index aed053d..658097e 100644 (file)
--- a/src/s4u/s4u_Comm.cpp
+++ b/src/s4u/s4u_Comm.cpp
@@ -57,7 +57,7 @@ void Comm::wait_all(std::vector<CommPtr>* comms)
     comm->wait();
 }
 
     comm->wait();
 }
 

-Activity* Comm::set_rate(double rate)
+Comm* Comm::set_rate(double rate)

 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);
 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);


@@ -65,7 +65,7 @@ Activity* Comm::set_rate(double rate)
   return this;
 }
 
   return this;
 }
 

-Activity* Comm::set_src_data(void* buff)
+Comm* Comm::set_src_data(void* buff)

 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);
 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);


@@ -73,14 +73,14 @@ Activity* Comm::set_src_data(void* buff)
   src_buff_ = buff;
   return this;
 }
   src_buff_ = buff;
   return this;
 }

-Activity* Comm::set_src_data_size(size_t size)
+Comm* Comm::set_src_data_size(size_t size)

 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);
   src_buff_size_ = size;
   return this;
 }
 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);
   src_buff_size_ = size;
   return this;
 }

-Activity* Comm::set_src_data(void* buff, size_t size)
+Comm* Comm::set_src_data(void* buff, size_t size)

 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);
 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);


@@ -90,7 +90,7 @@ Activity* Comm::set_src_data(void* buff, size_t size)
   src_buff_size_ = size;
   return this;
 }
   src_buff_size_ = size;
   return this;
 }

-Activity* Comm::set_dst_data(void** buff)
+Comm* Comm::set_dst_data(void** buff)

 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);
 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);


@@ -103,7 +103,7 @@ size_t Comm::get_dst_data_size()
   xbt_assert(state_ == State::FINISHED, "You cannot use %s before your communication terminated", __FUNCTION__);
   return dst_buff_size_;
 }
   xbt_assert(state_ == State::FINISHED, "You cannot use %s before your communication terminated", __FUNCTION__);
   return dst_buff_size_;
 }

-Activity* Comm::set_dst_data(void** buff, size_t size)
+Comm* Comm::set_dst_data(void** buff, size_t size)

 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);
 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);


@@ -114,7 +114,7 @@ Activity* Comm::set_dst_data(void** buff, size_t size)
   return this;
 }
 
   return this;
 }
 

-Activity* Comm::start()
+Comm* Comm::start()

 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);
 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);


@@ -137,7 +137,7 @@ Activity* Comm::start()
 }
 
 /** @brief Block the calling actor until the communication is finished */
 }
 
 /** @brief Block the calling actor until the communication is finished */

-Activity* Comm::wait()
+Comm* Comm::wait()

 {
   return this->wait_for(-1);
 }
 {
   return this->wait_for(-1);
 }


@@ -148,7 +148,7 @@ Activity* Comm::wait()
  *
  * @param timeout the amount of seconds to wait for the comm termination.
  *                Negative values denote infinite wait times. 0 as a timeout returns immediately. */
  *
  * @param timeout the amount of seconds to wait for the comm termination.
  *                Negative values denote infinite wait times. 0 as a timeout returns immediately. */

-Activity* Comm::wait_for(double timeout)
+Comm* Comm::wait_for(double timeout)

 {
   switch (state_) {
     case State::FINISHED:
 {
   switch (state_) {
     case State::FINISHED:


@@ -190,7 +190,7 @@ int Comm::test_any(std::vector<CommPtr>* comms)
   return res;
 }
 
   return res;
 }
 

-Activity* Comm::detach()
+Comm* Comm::detach()

 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);
 {
   xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
              __FUNCTION__);


@@ -199,7 +199,7 @@ Activity* Comm::detach()
   return start();
 }
 
   return start();
 }
 

-Activity* Comm::cancel()
+Comm* Comm::cancel()

 {
   simgrid::simix::simcall([this] { dynamic_cast<kernel::activity::CommImpl*>(pimpl_.get())->cancel(); });
   state_ = State::CANCELED;
 {
   simgrid::simix::simcall([this] { dynamic_cast<kernel::activity::CommImpl*>(pimpl_.get())->cancel(); });
   state_ = State::CANCELED;

diff --git a/src/s4u/s4u_Exec.cpp b/src/s4u/s4u_Exec.cpp
index 8250f94..884433a 100644 (file)
--- a/src/s4u/s4u_Exec.cpp
+++ b/src/s4u/s4u_Exec.cpp
@@ -15,7 +15,7 @@ namespace s4u {
 simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> s4u::Exec::on_start;
 simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> s4u::Exec::on_completion;
 
 simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> s4u::Exec::on_start;
 simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> s4u::Exec::on_completion;
 

-Activity* Exec::start()
+Exec* Exec::start()

 {
   pimpl_ = simcall_execution_start(name_, tracing_category_, flops_amount_, 1. / priority_, bound_, host_);
   state_ = State::STARTED;
 {
   pimpl_ = simcall_execution_start(name_, tracing_category_, flops_amount_, 1. / priority_, bound_, host_);
   state_ = State::STARTED;


@@ -23,14 +23,14 @@ Activity* Exec::start()
   return this;
 }
 
   return this;
 }
 

-Activity* Exec::cancel()
+Exec* Exec::cancel()

 {
   simgrid::simix::simcall([this] { dynamic_cast<kernel::activity::ExecImpl*>(pimpl_.get())->cancel(); });
   state_ = State::CANCELED;
   return this;
 }
 
 {
   simgrid::simix::simcall([this] { dynamic_cast<kernel::activity::ExecImpl*>(pimpl_.get())->cancel(); });
   state_ = State::CANCELED;
   return this;
 }
 

-Activity* Exec::wait()
+Exec* Exec::wait()

 {
   if (state_ == State::INITED)
     start();
 {
   if (state_ == State::INITED)
     start();


@@ -40,7 +40,7 @@ Activity* Exec::wait()
   return this;
 }
 
   return this;
 }
 

-Activity* Exec::wait_for(double timeout)
+Exec* Exec::wait_for(double timeout)

 {
   THROW_UNIMPLEMENTED;
   return this;
 {
   THROW_UNIMPLEMENTED;
   return this;

diff --git a/src/s4u/s4u_Io.cpp b/src/s4u/s4u_Io.cpp
index 25cb012..41a4cb3 100644 (file)
--- a/src/s4u/s4u_Io.cpp
+++ b/src/s4u/s4u_Io.cpp
@@ -14,7 +14,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_io, s4u_activity, "S4U asynchronous IOs");
 namespace simgrid {
 namespace s4u {
 
 namespace simgrid {
 namespace s4u {
 

-Activity* Io::start()
+Io* Io::start()

 {
   Activity::set_remaining(size_);
   pimpl_ = simix::simcall([this] {
 {
   Activity::set_remaining(size_);
   pimpl_ = simix::simcall([this] {


@@ -24,21 +24,21 @@ Activity* Io::start()
   return this;
 }
 
   return this;
 }
 

-Activity* Io::cancel()
+Io* Io::cancel()

 {
   simgrid::simix::simcall([this] { dynamic_cast<kernel::activity::IoImpl*>(pimpl_.get())->cancel(); });
   state_ = State::CANCELED;
   return this;
 }
 
 {
   simgrid::simix::simcall([this] { dynamic_cast<kernel::activity::IoImpl*>(pimpl_.get())->cancel(); });
   state_ = State::CANCELED;
   return this;
 }
 

-Activity* Io::wait()
+Io* Io::wait()

 {
   simcall_io_wait(pimpl_);
   state_ = State::FINISHED;
   return this;
 }
 
 {
   simcall_io_wait(pimpl_);
   state_ = State::FINISHED;
   return this;
 }
 

-Activity* Io::wait_for(double timeout)
+Io* Io::wait_for(double timeout)

 {
   THROW_UNIMPLEMENTED;
   return this;
 {
   THROW_UNIMPLEMENTED;
   return this;