From 7685128879fd2a88a5b9226114c223c65517668c Mon Sep 17 00:00:00 2001 From: Martin Quinson Date: Thu, 27 Sep 2018 01:05:15 +0200 Subject: [PATCH] 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. --- include/simgrid/s4u/Comm.hpp | 24 ++++++++++++------------ include/simgrid/s4u/Exec.hpp | 8 ++++---- include/simgrid/s4u/Io.hpp | 8 ++++---- src/s4u/s4u_Comm.cpp | 22 +++++++++++----------- src/s4u/s4u_Exec.cpp | 8 ++++---- src/s4u/s4u_Io.cpp | 8 ++++---- 6 files changed, 39 insertions(+), 39 deletions(-) diff --git a/include/simgrid/s4u/Comm.hpp b/include/simgrid/s4u/Comm.hpp index c9016f9da2..1b36069011 100644 --- 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 * 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. */ - Activity* detach(); + Comm* detach(); /** 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 */ - Activity* set_rate(double rate); + Comm* set_rate(double rate); /** 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. */ - 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()). @@ -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. */ - 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. @@ -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. */ - 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 */ - 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 */ - 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(); - Activity* cancel() override; + Comm* cancel() override; /** 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 18f00283e9..904540457f 100644 --- a/include/simgrid/s4u/Exec.hpp +++ b/include/simgrid/s4u/Exec.hpp @@ -31,10 +31,10 @@ public: static simgrid::xbt::signal on_start; static simgrid::xbt::signal 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); diff --git a/include/simgrid/s4u/Io.hpp b/include/simgrid/s4u/Io.hpp index 2fb16f1c6f..4e7ae31a54 100644 --- a/include/simgrid/s4u/Io.hpp +++ b/include/simgrid/s4u/Io.hpp @@ -33,10 +33,10 @@ public: ~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; diff --git a/src/s4u/s4u_Comm.cpp b/src/s4u/s4u_Comm.cpp index aed053d988..658097ea50 100644 --- a/src/s4u/s4u_Comm.cpp +++ b/src/s4u/s4u_Comm.cpp @@ -57,7 +57,7 @@ void Comm::wait_all(std::vector* comms) 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__); @@ -65,7 +65,7 @@ Activity* Comm::set_rate(double rate) 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__); @@ -73,14 +73,14 @@ Activity* Comm::set_src_data(void* buff) 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; } -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__); @@ -90,7 +90,7 @@ Activity* Comm::set_src_data(void* buff, size_t size) 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__); @@ -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_; } -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__); @@ -114,7 +114,7 @@ Activity* Comm::set_dst_data(void** buff, size_t size) return this; } -Activity* Comm::start() +Comm* Comm::start() { 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 */ -Activity* Comm::wait() +Comm* Comm::wait() { 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. */ -Activity* Comm::wait_for(double timeout) +Comm* Comm::wait_for(double timeout) { switch (state_) { case State::FINISHED: @@ -190,7 +190,7 @@ int Comm::test_any(std::vector* comms) return res; } -Activity* Comm::detach() +Comm* Comm::detach() { 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(); } -Activity* Comm::cancel() +Comm* Comm::cancel() { simgrid::simix::simcall([this] { dynamic_cast(pimpl_.get())->cancel(); }); state_ = State::CANCELED; diff --git a/src/s4u/s4u_Exec.cpp b/src/s4u/s4u_Exec.cpp index 8250f946a0..884433ac64 100644 --- a/src/s4u/s4u_Exec.cpp +++ b/src/s4u/s4u_Exec.cpp @@ -15,7 +15,7 @@ namespace s4u { simgrid::xbt::signal s4u::Exec::on_start; simgrid::xbt::signal 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; @@ -23,14 +23,14 @@ Activity* Exec::start() return this; } -Activity* Exec::cancel() +Exec* Exec::cancel() { simgrid::simix::simcall([this] { dynamic_cast(pimpl_.get())->cancel(); }); state_ = State::CANCELED; return this; } -Activity* Exec::wait() +Exec* Exec::wait() { if (state_ == State::INITED) start(); @@ -40,7 +40,7 @@ Activity* Exec::wait() return this; } -Activity* Exec::wait_for(double timeout) +Exec* Exec::wait_for(double timeout) { THROW_UNIMPLEMENTED; return this; diff --git a/src/s4u/s4u_Io.cpp b/src/s4u/s4u_Io.cpp index 25cb01261e..41a4cb3620 100644 --- 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 { -Activity* Io::start() +Io* Io::start() { Activity::set_remaining(size_); pimpl_ = simix::simcall([this] { @@ -24,21 +24,21 @@ Activity* Io::start() return this; } -Activity* Io::cancel() +Io* Io::cancel() { simgrid::simix::simcall([this] { dynamic_cast(pimpl_.get())->cancel(); }); state_ = State::CANCELED; return this; } -Activity* Io::wait() +Io* Io::wait() { 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; -- 2.20.1