#276: active: implement parameterization

Author: lifflander

examples/hello_world/hello_world.cc

@@ -49,24 +49,21 @@ struct HelloMsg : vt::Message {
   vt::NodeType from = 0;
 };
 
-static void hello_world(HelloMsg* msg) {
+void helloWorld(int a, int b, float c) {
   vt::NodeType this_node = vt::theContext()->getNode();
-  fmt::print("{}: Hello from node {}\n", this_node, msg->from);
+  fmt::print("{}: Hello from node vals = {} {} {}\n", this_node, a, b, c);
 }
 
 int main(int argc, char** argv) {
   vt::initialize(argc, argv);
 
-  vt::NodeType this_node = vt::theContext()->getNode();
   vt::NodeType num_nodes = vt::theContext()->getNumNodes();
-
   if (num_nodes == 1) {
     return vt::rerror("requires at least 2 nodes");
   }
 
   if (this_node == 0) {
-    auto msg = vt::makeMessage<HelloMsg>(this_node);
-    vt::theMsg()->broadcastMsg<hello_world>(msg);
+    vt::theMsg()->send<helloWorld>(1, 10, 20, 11.3f);
   }
 
   vt::finalize();

src/vt/messaging/active.h

@@ -56,6 +56,7 @@
 #include "vt/messaging/request_holder.h"
 #include "vt/messaging/send_info.h"
 #include "vt/messaging/async_op_wrapper.h"
+#include "vt/messaging/param_msg.h"
 #include "vt/event/event.h"
 #include "vt/registry/auto/auto_registry_interface.h"
 #include "vt/trace/trace_common.h"
@@ -756,6 +757,23 @@ struct ActiveMessenger : runtime::component::PollableComponent<ActiveMessenger>
     return sendMsg<MsgT, f>(dest, msg, tag);
   }
 
+  /**
+   * \brief Send parameters to a handler in a message
+   *
+   * \param[in] dest the destination node to send the message to
+   * \param[in] params the parameters
+   *
+   * \return the \c PendingSend for the sent message
+   */
+  template <auto f, typename... Params>
+  PendingSendType send(NodeType dest, Params&&... params) {
+    using Tuple = typename std::decay<std::tuple<Params...>>::type;
+    using MsgT = ParamMsg<Tuple>;
+    auto msg = vt::makeMessage<MsgT>(std::forward<Params>(params)...);
+    auto han = auto_registry::makeAutoHandlerParam<decltype(f),f,Params...>();
+    return sendMsg<MsgT>(dest, han, msg, no_tag);
+  }
+
   /**
    * \brief Send a message with explicit size.
    *

src/vt/messaging/param_msg.h

@@ -0,0 +1,72 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                                 param_msg.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2021 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_MESSAGING_PARAM_MSG_H
+#define INCLUDED_VT_MESSAGING_PARAM_MSG_H
+
+#include "vt/messaging/message/message_serialize.h"
+
+namespace vt { namespace messaging {
+
+template <typename Tuple>
+struct ParamMsg : vt::Message {
+  using MessageParentType = vt::Message;
+  vt_msg_serialize_if_needed_by_parent_or_type1(Tuple); // by tup
+
+  template <typename... Params>
+  explicit ParamMsg(Params&&... in_params)
+    : params(std::forward<Params>(in_params)...)
+  { }
+
+  Tuple params;
+
+  template <typename SerializerT>
+  void serialize(SerializerT& s) {
+    MessageParentType::serialize(s);
+    s | params;
+  }
+};
+
+}} /* end namespace vt::messaging */
+
+#endif /*INCLUDED_VT_MESSAGING_PARAM_MSG_H*/

src/vt/registry/auto/auto_registry_common.h

@@ -133,6 +133,21 @@ struct HandlersDispatcher final : BaseHandlersDispatcher {
     }
   };
 
+  template <typename T>
+  struct DispatchImpl<
+    T,
+    std::enable_if_t<
+      std::is_same<ObjT, SentinelObject>::value and
+      not std::is_same<T, ActiveVoidFnType*>::value and
+      not std::is_same<T, ActiveTypedFnType<MsgT>*>::value
+    >
+  > {
+    static void run(MsgT* msg, void*, HandlerT han) {
+      std::apply(han, msg->params);
+    }
+  };
+
+
 public:
   void dispatch(messaging::BaseMsg* msg, void* object) const override {
     DispatchImpl<HandlerT>::run(static_cast<MsgT*>(msg), object, fn_ptr_);

src/vt/registry/auto/auto_registry_general.h

@@ -45,6 +45,7 @@
 
 #include "vt/config.h"
 #include "vt/registry/auto/auto_registry_common.h"
+#include "vt/messaging/param_msg.h"
 
 #include "vt/utils/demangle/demangle.h"
 
@@ -154,10 +155,11 @@ struct FunctorAdapterArgs<ObjTypeT, MsgT> {
 
 // Need to provide a non-pointer overload for parameterization auto-registered
 // functions for GCC
-template <typename F, F f>
+template <typename F, F f, typename... Params>
 struct FunctorAdapterParam {
   using FunctionPtrType = F;
-  using ObjType = void;
+  using ObjType = SentinelObject;
+  using MsgType = messaging::ParamMsg<std::tuple<Params...>>;
 
   static constexpr FunctionPtrType getFunction() { return f; }
 

src/vt/registry/auto/auto_registry_impl.h

@@ -144,9 +144,9 @@ inline BaseScatterDispatcherPtr const& getScatterAutoHandler(HandlerType const h
   return getAutoRegistryGen<ScatterContainerType>().at(han_id).getFun();
 }
 
-template <typename T, T value>
+template <typename T, T value, typename... Params>
 inline HandlerType makeAutoHandlerParam() {
-  using AdapterT = FunctorAdapterParam<T, value>;
+  using AdapterT = FunctorAdapterParam<T, value, Params...>;
   using ContainerType = AutoActiveContainerType;
   using RegInfoType = AutoRegInfoType<AutoActiveType>;
   using FuncType = ActiveFnPtrType;