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 <pup.h>
      10             : #include <tuple>
      11             : #include <utility>
      12             : 
      13             : #include "Parallel/Invoke.hpp"
      14             : #include "Utilities/Serialization/CharmPupable.hpp"
      15             : #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
      16             : 
      17             : namespace Parallel {
      18             : /// An abstract base class, whose derived class holds a function that
      19             : /// can be invoked at a later time.  The function is intended to be
      20             : /// invoked only once.
      21           1 : class Callback : public PUP::able {
      22             :  public:
      23           0 :   WRAPPED_PUPable_abstract(Callback);  // NOLINT
      24           0 :   Callback() = default;
      25           0 :   Callback(const Callback&) = default;
      26           0 :   Callback& operator=(const Callback&) = default;
      27           0 :   Callback(Callback&&) = default;
      28           0 :   Callback& operator=(Callback&&) = default;
      29           0 :   ~Callback() override = default;
      30           0 :   explicit Callback(CkMigrateMessage* msg) : PUP::able(msg) {}
      31           0 :   virtual void invoke() = 0;
      32           0 :   virtual void register_with_charm() = 0;
      33             : };
      34             : 
      35             : /// Wraps a call to a simple action and its arguments.
      36             : /// Can be invoked only once.
      37             : template <typename SimpleAction, typename Proxy, typename... Args>
      38           1 : class SimpleActionCallback : public Callback {
      39             :  public:
      40           0 :   WRAPPED_PUPable_decl_template(SimpleActionCallback);  // NOLINT
      41           0 :   SimpleActionCallback() = default;
      42             :   // NOLINTNEXTLINE(google-explicit-constructor)
      43           0 :   SimpleActionCallback(Proxy proxy, std::decay_t<Args>... args)
      44             :       : proxy_(proxy), args_(std::move(args)...) {}
      45           0 :   SimpleActionCallback(CkMigrateMessage* msg) : Callback(msg) {}
      46             :   using PUP::able::register_constructor;
      47           0 :   void invoke() override {
      48             :     std::apply(
      49             :         [this](auto&&... args) {
      50             :           Parallel::simple_action<SimpleAction>(proxy_, args...);
      51             :         },
      52             :         std::move(args_));
      53             :   }
      54           0 :   void pup(PUP::er& p) override {
      55             :     p | proxy_;
      56             :     p | args_;
      57             :   }
      58             : 
      59           0 :   void register_with_charm() override {
      60             :     static bool done_registration{false};
      61             :     if (done_registration) {
      62             :       return;
      63             :     }
      64             :     done_registration = true;
      65             :     register_classes_with_charm<SimpleActionCallback>();
      66             :   }
      67             : 
      68             :  private:
      69           0 :   std::decay_t<Proxy> proxy_{};
      70           0 :   std::tuple<std::decay_t<Args>...> args_{};
      71             : };
      72             : 
      73             : /// Wraps a call to a simple action without arguments.
      74             : template <typename SimpleAction, typename Proxy>
      75           1 : class SimpleActionCallback<SimpleAction, Proxy> : public Callback {
      76             :  public:
      77           0 :   WRAPPED_PUPable_decl_template(SimpleActionCallback);  // NOLINT
      78           0 :   SimpleActionCallback() = default;
      79             :   // NOLINTNEXTLINE(google-explicit-constructor)
      80           0 :   SimpleActionCallback(Proxy proxy) : proxy_(proxy) {}
      81           0 :   SimpleActionCallback(CkMigrateMessage* msg) : Callback(msg) {}
      82             :   using PUP::able::register_constructor;
      83           0 :   void invoke() override { Parallel::simple_action<SimpleAction>(proxy_); }
      84             : 
      85           0 :   void pup(PUP::er& p) override { p | proxy_; }
      86             : 
      87           0 :   void register_with_charm() override {
      88             :     static bool done_registration{false};
      89             :     if (done_registration) {
      90             :       return;
      91             :     }
      92             :     done_registration = true;
      93             :     register_classes_with_charm<SimpleActionCallback>();
      94             :   }
      95             : 
      96             :  private:
      97           0 :   std::decay_t<Proxy> proxy_{};
      98             : };
      99             : 
     100             : /// Wraps a call to perform_algorithm.
     101             : template <typename Proxy>
     102           1 : class PerformAlgorithmCallback : public Callback {
     103             :  public:
     104           0 :   WRAPPED_PUPable_decl_template(PerformAlgorithmCallback);  // NOLINT
     105           0 :   PerformAlgorithmCallback() = default;
     106             :   // NOLINTNEXTLINE(google-explicit-constructor)
     107           0 :   PerformAlgorithmCallback(Proxy proxy) : proxy_(proxy) {}
     108           0 :   PerformAlgorithmCallback(CkMigrateMessage* msg) : Callback(msg) {}
     109             :   using PUP::able::register_constructor;
     110           0 :   void invoke() override { proxy_.perform_algorithm(); }
     111           0 :   void pup(PUP::er& p) override { p | proxy_; }
     112             : 
     113           0 :   void register_with_charm() override {
     114             :     static bool done_registration{false};
     115             :     if (done_registration) {
     116             :       return;
     117             :     }
     118             :     done_registration = true;
     119             :     register_classes_with_charm<PerformAlgorithmCallback>();
     120             :   }
     121             : 
     122             :  private:
     123           0 :   std::decay_t<Proxy> proxy_{};
     124             : };
     125             : 
     126             : /// \cond
     127             : template <typename Proxy>
     128             : PUP::able::PUP_ID PerformAlgorithmCallback<Proxy>::my_PUP_ID = 0;  // NOLINT
     129             : template <typename SimpleAction, typename Proxy, typename... Args>
     130             : PUP::able::PUP_ID
     131             :     SimpleActionCallback<SimpleAction, Proxy, Args...>::my_PUP_ID =
     132             :         0;  // NOLINT
     133             : template <typename SimpleAction, typename Proxy>
     134             : PUP::able::PUP_ID SimpleActionCallback<SimpleAction, Proxy>::my_PUP_ID =
     135             :     0;  // NOLINT
     136             : /// \endcond
     137             : 
     138             : }  // namespace Parallel