Register derived parallel callbacks

src/Parallel/Callback.hpp

@@ -12,6 +12,7 @@
 
 #include "Parallel/Invoke.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
+#include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
 
 namespace Parallel {
 /// An abstract base class, whose derived class holds a function that
@@ -28,6 +29,7 @@ class Callback : public PUP::able {
   ~Callback() override = default;
   explicit Callback(CkMigrateMessage* msg) : PUP::able(msg) {}
   virtual void invoke() = 0;
+  virtual void register_with_charm() = 0;
 };
 
 /// Wraps a call to a simple action and its arguments.
@@ -54,8 +56,17 @@ class SimpleActionCallback : public Callback {
     p | args_;
   }
 
+  void register_with_charm() override {
+    static bool done_registration{false};
+    if (done_registration) {
+      return;
+    }
+    done_registration = true;
+    register_classes_with_charm<SimpleActionCallback>();
+  }
+
  private:
-  Proxy proxy_{};
+  std::decay_t<Proxy> proxy_{};
   std::tuple<std::decay_t<Args>...> args_{};
 };
 
@@ -65,15 +76,25 @@ class SimpleActionCallback<SimpleAction, Proxy> : public Callback {
  public:
   WRAPPED_PUPable_decl_template(SimpleActionCallback);  // NOLINT
   SimpleActionCallback() = default;
+  // NOLINTNEXTLINE(google-explicit-constructor)
   SimpleActionCallback(Proxy proxy) : proxy_(proxy) {}
   SimpleActionCallback(CkMigrateMessage* msg) : Callback(msg) {}
   using PUP::able::register_constructor;
   void invoke() override { Parallel::simple_action<SimpleAction>(proxy_); }
 
   void pup(PUP::er& p) override { p | proxy_; }
 
+  void register_with_charm() override {
+    static bool done_registration{false};
+    if (done_registration) {
+      return;
+    }
+    done_registration = true;
+    register_classes_with_charm<SimpleActionCallback>();
+  }
+
  private:
-  Proxy proxy_{};
+  std::decay_t<Proxy> proxy_{};
 };
 
 /// Wraps a call to perform_algorithm.
@@ -82,14 +103,24 @@ class PerformAlgorithmCallback : public Callback {
  public:
   WRAPPED_PUPable_decl_template(PerformAlgorithmCallback);  // NOLINT
   PerformAlgorithmCallback() = default;
+  // NOLINTNEXTLINE(google-explicit-constructor)
   PerformAlgorithmCallback(Proxy proxy) : proxy_(proxy) {}
   PerformAlgorithmCallback(CkMigrateMessage* msg) : Callback(msg) {}
   using PUP::able::register_constructor;
   void invoke() override { proxy_.perform_algorithm(); }
   void pup(PUP::er& p) override { p | proxy_; }
 
+  void register_with_charm() override {
+    static bool done_registration{false};
+    if (done_registration) {
+      return;
+    }
+    done_registration = true;
+    register_classes_with_charm<PerformAlgorithmCallback>();
+  }
+
  private:
-  Proxy proxy_{};
+  std::decay_t<Proxy> proxy_{};
 };
 
 /// \cond

src/Parallel/GlobalCache.hpp

@@ -466,6 +466,7 @@ bool GlobalCache<Metavariables>::mutable_cache_item_is_ready(
   };
 
   if (callback_was_registered()) {
+    optional_callback->register_with_charm();
     // Second mutex is for vector of callbacks
     std::mutex& mutex = tuples::get<MutexTag<tag>>(mutexes_).second;
     {

tests/Unit/Framework/ActionTesting.hpp

@@ -6,6 +6,7 @@
 #include <algorithm>
 #include <charm++.h>
 #include <cstddef>
+#include <memory>
 #include <optional>
 #include <tuple>
 #include <unordered_map>
@@ -457,13 +458,15 @@ class MockDistributedObjectProxy : public CProxyElement_ArrayElement {
  public:
   using Inbox = tuples::tagged_tuple_from_typelist<InboxTagList>;
 
+  MockDistributedObjectProxy() = default;
+
   MockDistributedObjectProxy(
       size_t mock_node, size_t mock_local_core,
       MockDistributedObject<Component>& mock_distributed_object, Inbox& inbox)
       : mock_node_(mock_node),
         mock_local_core_(mock_local_core),
-        mock_distributed_object_(mock_distributed_object),
-        inbox_(inbox) {}
+        mock_distributed_object_(&mock_distributed_object),
+        inbox_(&inbox) {}
 
   template <typename InboxTag, typename Data>
   void receive_data(const typename InboxTag::temporal_id& id, Data&& data,
@@ -472,49 +475,49 @@ class MockDistributedObjectProxy : public CProxyElement_ArrayElement {
     // not needed now. However, it is required by the interface to be compliant
     // with the Algorithm invocations.
     (void)enable_if_disabled;
-    InboxTag::insert_into_inbox(make_not_null(&tuples::get<InboxTag>(inbox_)),
+    InboxTag::insert_into_inbox(make_not_null(&tuples::get<InboxTag>(*inbox_)),
                                 id, std::forward<Data>(data));
   }
 
   template <typename InboxTag, typename MessageType>
   void receive_data(MessageType* message) {
-    InboxTag::insert_into_inbox(make_not_null(&tuples::get<InboxTag>(inbox_)),
+    InboxTag::insert_into_inbox(make_not_null(&tuples::get<InboxTag>(*inbox_)),
                                 message);
   }
 
   template <typename Action, typename... Args>
   void simple_action(std::tuple<Args...> args) {
-    mock_distributed_object_.template simple_action<Action>(std::move(args));
+    mock_distributed_object_->template simple_action<Action>(std::move(args));
   }
 
   template <typename Action>
   void simple_action() {
-    mock_distributed_object_.template simple_action<Action>();
+    mock_distributed_object_->template simple_action<Action>();
   }
 
   template <typename Action, typename... Args>
   void threaded_action(std::tuple<Args...> args) {
-    mock_distributed_object_.template threaded_action<Action>(std::move(args));
+    mock_distributed_object_->template threaded_action<Action>(std::move(args));
   }
 
   template <typename Action>
   void threaded_action() {
-    mock_distributed_object_.template threaded_action<Action>();
+    mock_distributed_object_->template threaded_action<Action>();
   }
 
-  void set_terminate(bool t) { mock_distributed_object_.set_terminate(t); }
+  void set_terminate(bool t) { mock_distributed_object_->set_terminate(t); }
 
   // Actions may call this, but since tests step through actions manually it has
   // no effect.
   void perform_algorithm() {}
   void perform_algorithm(const bool /*restart_if_terminated*/) {}
 
   MockDistributedObject<Component>* ckLocal() {
-    return (mock_distributed_object_.my_node() ==
+    return (mock_distributed_object_->my_node() ==
                 static_cast<int>(mock_node_) and
-            mock_distributed_object_.my_local_rank() ==
+            mock_distributed_object_->my_local_rank() ==
                 static_cast<int>(mock_local_core_))
-               ? &mock_distributed_object_
+               ? mock_distributed_object_
                : nullptr;
   }
 
@@ -549,8 +552,8 @@ class MockDistributedObjectProxy : public CProxyElement_ArrayElement {
   // lives on.
   size_t mock_node_{0};
   size_t mock_local_core_{0};
-  MockDistributedObject<Component>& mock_distributed_object_;
-  Inbox& inbox_;
+  MockDistributedObject<Component>* mock_distributed_object_{nullptr};
+  Inbox* inbox_{nullptr};
 };
 
 template <typename ChareType>

tests/Unit/Parallel/Test_GlobalCache.cpp

@@ -224,6 +224,8 @@ class UseCkCallbackAsCallback : public Parallel::Callback {
   using PUP::able::register_constructor;
   void invoke() override { callback_.send(nullptr); }
   void pup(PUP::er& p) override { p | callback_; }
+  // We shouldn't be pupping so registration doesn't matter
+  void register_with_charm() override {}
 
  private:
   CkCallback callback_;