Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines Parallel::Callback.
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <memory>
      10             : #include <pup.h>
      11             : #include <tuple>
      12             : #include <utility>
      13             : 
      14             : #include "Parallel/Invoke.hpp"
      15             : #include "Utilities/PrettyType.hpp"
      16             : #include "Utilities/Serialization/CharmPupable.hpp"
      17             : #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
      18             : #include "Utilities/TypeTraits/HasEquivalence.hpp"
      19             : 
      20             : namespace Parallel {
      21             : namespace detail {
      22             : // Not all tuple arguments are guaranteed to have operator==, so we check the
      23             : // ones we can.
      24             : template <typename... Args>
      25             : bool tuple_equal(const std::tuple<Args...>& tuple_1,
      26             :                  const std::tuple<Args...>& tuple_2) {
      27             :   bool result = true;
      28             :   tmpl::for_each<tmpl::make_sequence<tmpl::size_t<0>,
      29             :                                      tmpl::size<tmpl::list<Args...>>::value>>(
      30             :       [&](const auto index_v) {
      31             :         constexpr size_t index = tmpl::type_from<decltype(index_v)>::value;
      32             : 
      33             :         if (not result) {
      34             :           return;
      35             :         }
      36             : 
      37             :         if constexpr (tt::has_equivalence_v<decltype(std::get<index>(
      38             :                           tuple_1))>) {
      39             :           result =
      40             :               result and std::get<index>(tuple_1) == std::get<index>(tuple_2);
      41             :         }
      42             :       });
      43             : 
      44             :   return result;
      45             : }
      46             : }  // namespace detail
      47             : 
      48             : /// An abstract base class, whose derived class holds a function that
      49             : /// can be invoked at a later time.  The function is intended to be
      50             : /// invoked only once.
      51           1 : class Callback : public PUP::able {
      52             :  public:
      53           0 :   WRAPPED_PUPable_abstract(Callback);  // NOLINT
      54           0 :   Callback() = default;
      55           0 :   Callback(const Callback&) = default;
      56           0 :   Callback& operator=(const Callback&) = default;
      57           0 :   Callback(Callback&&) = default;
      58           0 :   Callback& operator=(Callback&&) = default;
      59           0 :   ~Callback() override = default;
      60           0 :   explicit Callback(CkMigrateMessage* msg) : PUP::able(msg) {}
      61           0 :   virtual void invoke() = 0;
      62           0 :   virtual void register_with_charm() = 0;
      63             :   /*!
      64             :    * \brief Returns if this callback is equal to the one passed in.
      65             :    */
      66           1 :   virtual bool is_equal_to(const Callback& rhs) const = 0;
      67           0 :   virtual std::string name() const = 0;
      68           0 :   virtual std::unique_ptr<Callback> get_clone() = 0;
      69             : };
      70             : 
      71             : /// Wraps a call to a simple action and its arguments.
      72             : /// Can be invoked only once.
      73             : template <typename SimpleAction, typename Proxy, typename... Args>
      74           1 : class SimpleActionCallback : public Callback {
      75             :  public:
      76           0 :   WRAPPED_PUPable_decl_template(SimpleActionCallback);  // NOLINT
      77           0 :   SimpleActionCallback() = default;
      78             :   // NOLINTNEXTLINE(google-explicit-constructor)
      79           0 :   SimpleActionCallback(Proxy proxy, std::decay_t<Args>... args)
      80             :       : proxy_(proxy), args_(std::move(args)...) {}
      81           0 :   explicit SimpleActionCallback(CkMigrateMessage* msg) : Callback(msg) {}
      82             :   using PUP::able::register_constructor;
      83           0 :   void invoke() override {
      84             :     std::apply(
      85             :         [this](auto&&... args) {
      86             :           Parallel::simple_action<SimpleAction>(proxy_, args...);
      87             :         },
      88             :         std::move(args_));
      89             :   }
      90           0 :   void pup(PUP::er& p) override {
      91             :     p | proxy_;
      92             :     p | args_;
      93             :   }
      94             : 
      95           0 :   void register_with_charm() override {
      96             :     static bool done_registration{false};
      97             :     if (done_registration) {
      98             :       return;
      99             :     }
     100             :     done_registration = true;
     101             :     register_classes_with_charm<SimpleActionCallback>();
     102             :   }
     103             : 
     104           1 :   bool is_equal_to(const Callback& rhs) const override {
     105             :     const auto* downcast_ptr = dynamic_cast<const SimpleActionCallback*>(&rhs);
     106             :     if (downcast_ptr == nullptr) {
     107             :       return false;
     108             :     }
     109             :     return detail::tuple_equal(args_, downcast_ptr->args_);
     110             :   }
     111             : 
     112           0 :   std::string name() const override {
     113             :     // Use pretty_type::get_name with the action since we want to differentiate
     114             :     // template paremeters. Only use pretty_type::name for proxy because it'll
     115             :     // likely be really long with the template parameters which is unnecessary
     116             :     return "SimpleActionCallback(" + pretty_type::get_name<SimpleAction>() +
     117             :            "," + pretty_type::name<Proxy>() + ")";
     118             :   }
     119             : 
     120           0 :   std::unique_ptr<Callback> get_clone() override {
     121             :     return std::make_unique<SimpleActionCallback<SimpleAction, Proxy, Args...>>(
     122             :         *this);
     123             :   }
     124             : 
     125             :  private:
     126           0 :   std::decay_t<Proxy> proxy_{};
     127           0 :   std::tuple<std::decay_t<Args>...> args_{};
     128             : };
     129             : 
     130             : /// Wraps a call to a simple action without arguments.
     131             : template <typename SimpleAction, typename Proxy>
     132           1 : class SimpleActionCallback<SimpleAction, Proxy> : public Callback {
     133             :  public:
     134           0 :   WRAPPED_PUPable_decl_template(SimpleActionCallback);  // NOLINT
     135           0 :   SimpleActionCallback() = default;
     136             :   // NOLINTNEXTLINE(google-explicit-constructor)
     137           0 :   SimpleActionCallback(Proxy proxy) : proxy_(proxy) {}
     138           0 :   explicit SimpleActionCallback(CkMigrateMessage* msg) : Callback(msg) {}
     139             :   using PUP::able::register_constructor;
     140           0 :   void invoke() override { Parallel::simple_action<SimpleAction>(proxy_); }
     141             : 
     142           0 :   void pup(PUP::er& p) override { p | proxy_; }
     143             : 
     144           0 :   void register_with_charm() override {
     145             :     static bool done_registration{false};
     146             :     if (done_registration) {
     147             :       return;
     148             :     }
     149             :     done_registration = true;
     150             :     register_classes_with_charm<SimpleActionCallback>();
     151             :   }
     152             : 
     153           1 :   bool is_equal_to(const Callback& rhs) const override {
     154             :     const auto* downcast_ptr = dynamic_cast<const SimpleActionCallback*>(&rhs);
     155             :     return downcast_ptr != nullptr;
     156             :   }
     157             : 
     158           0 :   std::string name() const override {
     159             :     // Use pretty_type::get_name with the action since we want to differentiate
     160             :     // template paremeters. Only use pretty_type::name for proxy because it'll
     161             :     // likely be really long with the template parameters which is unnecessary
     162             :     return "SimpleActionCallback(" + pretty_type::get_name<SimpleAction>() +
     163             :            "," + pretty_type::name<Proxy>() + ")";
     164             :   }
     165             : 
     166           0 :   std::unique_ptr<Callback> get_clone() override {
     167             :     return std::make_unique<SimpleActionCallback<SimpleAction, Proxy>>(*this);
     168             :   }
     169             : 
     170             :  private:
     171           0 :   std::decay_t<Proxy> proxy_{};
     172             : };
     173             : 
     174             : /// Wraps a call to a threaded action and its arguments.
     175             : /// Can be invoked only once.
     176             : template <typename ThreadedAction, typename Proxy, typename... Args>
     177           1 : class ThreadedActionCallback : public Callback {
     178             :  public:
     179           0 :   WRAPPED_PUPable_decl_template(ThreadedActionCallback);  // NOLINT
     180           0 :   ThreadedActionCallback() = default;
     181             :   // NOLINTNEXTLINE(google-explicit-constructor)
     182           0 :   ThreadedActionCallback(Proxy proxy, std::decay_t<Args>... args)
     183             :       : proxy_(proxy), args_(std::move(args)...) {}
     184           0 :   explicit ThreadedActionCallback(CkMigrateMessage* msg) : Callback(msg) {}
     185             :   using PUP::able::register_constructor;
     186           0 :   void invoke() override {
     187             :     std::apply(
     188             :         [this](auto&&... args) {
     189             :           Parallel::threaded_action<ThreadedAction>(proxy_, args...);
     190             :         },
     191             :         std::move(args_));
     192             :   }
     193           0 :   void pup(PUP::er& p) override {
     194             :     p | proxy_;
     195             :     p | args_;
     196             :   }
     197             : 
     198           0 :   void register_with_charm() override {
     199             :     static bool done_registration{false};
     200             :     if (done_registration) {
     201             :       return;
     202             :     }
     203             :     done_registration = true;
     204             :     register_classes_with_charm<ThreadedActionCallback>();
     205             :   }
     206             : 
     207           1 :   bool is_equal_to(const Callback& rhs) const override {
     208             :     const auto* downcast_ptr =
     209             :         dynamic_cast<const ThreadedActionCallback*>(&rhs);
     210             :     if (downcast_ptr == nullptr) {
     211             :       return false;
     212             :     }
     213             :     return detail::tuple_equal(args_, downcast_ptr->args_);
     214             :   }
     215             : 
     216           0 :   std::string name() const override {
     217             :     // Use pretty_type::get_name with the action since we want to differentiate
     218             :     // template paremeters. Only use pretty_type::name for proxy because it'll
     219             :     // likely be really long with the template parameters which is unnecessary
     220             :     return "ThreadedActionCallback(" + pretty_type::get_name<ThreadedAction>() +
     221             :            "," + pretty_type::name<Proxy>() + ")";
     222             :   }
     223             : 
     224           0 :   std::unique_ptr<Callback> get_clone() override {
     225             :     return std::make_unique<
     226             :         ThreadedActionCallback<ThreadedAction, Proxy, Args...>>(*this);
     227             :   }
     228             : 
     229             :  private:
     230           0 :   std::decay_t<Proxy> proxy_{};
     231           0 :   std::tuple<std::decay_t<Args>...> args_{};
     232             : };
     233             : 
     234             : /// Wraps a call to a threaded action without arguments.
     235             : template <typename ThreadedAction, typename Proxy>
     236           1 : class ThreadedActionCallback<ThreadedAction, Proxy> : public Callback {
     237             :  public:
     238           0 :   WRAPPED_PUPable_decl_template(ThreadedActionCallback);  // NOLINT
     239           0 :   ThreadedActionCallback() = default;
     240             :   // NOLINTNEXTLINE(google-explicit-constructor)
     241           0 :   ThreadedActionCallback(Proxy proxy) : proxy_(proxy) {}
     242           0 :   explicit ThreadedActionCallback(CkMigrateMessage* msg) : Callback(msg) {}
     243             :   using PUP::able::register_constructor;
     244           0 :   void invoke() override { Parallel::threaded_action<ThreadedAction>(proxy_); }
     245             : 
     246           0 :   void pup(PUP::er& p) override { p | proxy_; }
     247             : 
     248           0 :   void register_with_charm() override {
     249             :     static bool done_registration{false};
     250             :     if (done_registration) {
     251             :       return;
     252             :     }
     253             :     done_registration = true;
     254             :     register_classes_with_charm<ThreadedActionCallback>();
     255             :   }
     256             : 
     257           1 :   bool is_equal_to(const Callback& rhs) const override {
     258             :     const auto* downcast_ptr =
     259             :         dynamic_cast<const ThreadedActionCallback*>(&rhs);
     260             :     return downcast_ptr != nullptr;
     261             :   }
     262             : 
     263           0 :   std::string name() const override {
     264             :     // Use pretty_type::get_name with the action since we want to differentiate
     265             :     // template paremeters. Only use pretty_type::name for proxy because it'll
     266             :     // likely be really long with the template parameters which is unnecessary
     267             :     return "ThreadedActionCallback(" + pretty_type::get_name<ThreadedAction>() +
     268             :            "," + pretty_type::name<Proxy>() + ")";
     269             :   }
     270             : 
     271           0 :   std::unique_ptr<Callback> get_clone() override {
     272             :     return std::make_unique<ThreadedActionCallback<ThreadedAction, Proxy>>(
     273             :         *this);
     274             :   }
     275             : 
     276             :  private:
     277           0 :   std::decay_t<Proxy> proxy_{};
     278             : };
     279             : 
     280             : /// Wraps a call to perform_algorithm.
     281             : template <typename Proxy>
     282           1 : class PerformAlgorithmCallback : public Callback {
     283             :  public:
     284           0 :   WRAPPED_PUPable_decl_template(PerformAlgorithmCallback);  // NOLINT
     285           0 :   PerformAlgorithmCallback() = default;
     286             :   // NOLINTNEXTLINE(google-explicit-constructor)
     287           0 :   PerformAlgorithmCallback(Proxy proxy) : proxy_(proxy) {}
     288           0 :   explicit PerformAlgorithmCallback(CkMigrateMessage* msg) : Callback(msg) {}
     289             :   using PUP::able::register_constructor;
     290           0 :   void invoke() override { proxy_.perform_algorithm(); }
     291           0 :   void pup(PUP::er& p) override { p | proxy_; }
     292             : 
     293           0 :   void register_with_charm() override {
     294             :     static bool done_registration{false};
     295             :     if (done_registration) {
     296             :       return;
     297             :     }
     298             :     done_registration = true;
     299             :     register_classes_with_charm<PerformAlgorithmCallback>();
     300             :   }
     301             : 
     302           1 :   bool is_equal_to(const Callback& rhs) const override {
     303             :     const auto* downcast_ptr =
     304             :         dynamic_cast<const PerformAlgorithmCallback*>(&rhs);
     305             :     return downcast_ptr != nullptr;
     306             :   }
     307             : 
     308           0 :   std::string name() const override {
     309             :     // Only use pretty_type::name for proxy because it'll likely be really long
     310             :     // with the template parameters which is unnecessary
     311             :     return "PerformAlgorithmCallback(" + pretty_type::name<Proxy>() + ")";
     312             :   }
     313             : 
     314           0 :   std::unique_ptr<Callback> get_clone() override {
     315             :     return std::make_unique<PerformAlgorithmCallback<Proxy>>(*this);
     316             :   }
     317             : 
     318             :  private:
     319           0 :   std::decay_t<Proxy> proxy_{};
     320             : };
     321             : 
     322             : /// \cond
     323             : template <typename Proxy>
     324             : // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
     325             : PUP::able::PUP_ID PerformAlgorithmCallback<Proxy>::my_PUP_ID = 0;
     326             : template <typename SimpleAction, typename Proxy, typename... Args>
     327             : PUP::able::PUP_ID
     328             :     // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
     329             :     SimpleActionCallback<SimpleAction, Proxy, Args...>::my_PUP_ID =
     330             :         0;  // NOLINT
     331             : template <typename SimpleAction, typename Proxy>
     332             : // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
     333             : PUP::able::PUP_ID SimpleActionCallback<SimpleAction, Proxy>::my_PUP_ID =
     334             :     0;  // NOLINT
     335             : template <typename ThreadedAction, typename Proxy, typename... Args>
     336             : PUP::able::PUP_ID
     337             :     // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
     338             :     ThreadedActionCallback<ThreadedAction, Proxy, Args...>::my_PUP_ID =
     339             :         0;  // NOLINT
     340             : template <typename ThreadedAction, typename Proxy>
     341             : // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
     342             : PUP::able::PUP_ID ThreadedActionCallback<ThreadedAction, Proxy>::my_PUP_ID =
     343             :     0;  // NOLINT
     344             : /// \endcond
     345             : 
     346             : }  // namespace Parallel