Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <cstddef>
       7             : #include <type_traits>
       8             : #include <utility>
       9             : 
      10             : #include "Parallel/Local.hpp"
      11             : #include "Parallel/MaxInlineMethodsReached.hpp"
      12             : #include "Parallel/TypeTraits.hpp"
      13             : 
      14             : namespace Parallel {
      15             : /*!
      16             :  * \ingroup ParallelGroup
      17             :  * \brief Send the data `args...` to the algorithm running on `proxy`, and tag
      18             :  * the message with the identifier `temporal_id`.
      19             :  *
      20             :  * If the algorithm was previously disabled, set `enable_if_disabled` to true to
      21             :  * enable the algorithm on the parallel component.
      22             :  */
      23             : template <typename ReceiveTag, typename Proxy, typename ReceiveDataType>
      24           1 : void receive_data(Proxy&& proxy, typename ReceiveTag::temporal_id temporal_id,
      25             :                   ReceiveDataType&& receive_data,
      26             :                   const bool enable_if_disabled = false) {
      27             :   // Both branches of this if statement call into the charm proxy system, but
      28             :   // because we specify [inline] for array chares, we must specify the
      29             :   // `ReceiveDataType` explicitly in the template arguments when dispatching to
      30             :   // array chares.
      31             :   // This is required because of inconsistent overloads in the generated charm++
      32             :   // files when [inline] is specified vs when it is not. The [inline] version
      33             :   // generates a function signature with template parameters associated with
      34             :   // each function argument, ensuring a redundant template parameter for the
      35             :   // `ReceiveDataType`. Then, that template parameter cannot be inferred so must
      36             :   // be explicitly specified.
      37             :   if constexpr (is_array_proxy<std::decay_t<Proxy>>::value) {
      38             :     proxy.template receive_data<ReceiveTag, std::decay_t<ReceiveDataType>>(
      39             :         std::move(temporal_id), std::forward<ReceiveDataType>(receive_data),
      40             :         enable_if_disabled);
      41             :   } else {
      42             :     proxy.template receive_data<ReceiveTag>(
      43             :         std::move(temporal_id), std::forward<ReceiveDataType>(receive_data),
      44             :         enable_if_disabled);
      45             :   }
      46             : }
      47             : 
      48             : /*!
      49             :  * \ingroup ParallelGroup
      50             :  * \brief Send a pointer `message` to the algorithm running on `proxy`.
      51             :  *
      52             :  * Here, `message` should hold all the information you need as member variables
      53             :  * of the object. This includes, temporal ID identifiers, the data itself, and
      54             :  * any auxilary information that needs to be communicated. The `ReceiveTag`
      55             :  * associated with this `message` should be able unpack the information that was
      56             :  * sent.
      57             :  *
      58             :  * If the component associated with the `proxy` you are calling this on is
      59             :  * running on the same charm-node, the exact pointer `message` is sent to the
      60             :  * receiving component. No copies of data are done. If the receiving component
      61             :  * is on a different charm-node, then the data pointed to by `message` is
      62             :  * copied, sent through charm, and unpacked on the receiving component. The
      63             :  * pointer that is passed to the algorithm on the receiving component then
      64             :  * points to the copied data on the receiving component.
      65             :  *
      66             :  * \warning You cannot use the `message` pointer after you call this function.
      67             :  * Doing so will result in undefined behavior because something else may be
      68             :  * controlling the pointer.
      69             :  */
      70             : template <typename ReceiveTag, typename Proxy, typename MessageType>
      71           1 : void receive_data(Proxy&& proxy, MessageType* message) {
      72             :   static_assert(is_array_proxy<std::decay_t<Proxy>>::value or
      73             :                     is_array_element_proxy<std::decay_t<Proxy>>::value,
      74             :                 "Charm++ messages can only be used with Array[Element] chares "
      75             :                 "at the moment. If you want to use them with other types of "
      76             :                 "components, you will need to implement it.");
      77             :   proxy.template receive_data<ReceiveTag, std::decay_t<MessageType>>(message);
      78             : }
      79             : 
      80             : /// @{
      81             : /*!
      82             :  * \ingroup ParallelGroup
      83             :  * \brief Invoke a simple action on `proxy`
      84             :  */
      85             : template <typename Action, typename Proxy>
      86           1 : void simple_action(Proxy&& proxy) {
      87             :   proxy.template simple_action<Action>();
      88             : }
      89             : 
      90             : template <typename Action, typename Proxy, typename Arg0, typename... Args>
      91           1 : void simple_action(Proxy&& proxy, Arg0&& arg0, Args&&... args) {
      92             :   proxy.template simple_action<Action, std::decay_t<Arg0>,
      93             :                                std::decay_t<Args>...>(
      94             :       std::tuple<std::decay_t<Arg0>, std::decay_t<Args>...>(
      95             :           std::forward<Arg0>(arg0), std::forward<Args>(args)...));
      96             : }
      97             : /// @}
      98             : 
      99             : /*!
     100             :  * \ingroup ParallelGroup
     101             :  * \brief Invoke a local synchronous action on `proxy`
     102             :  */
     103             : template <typename Action, typename Proxy, typename... Args>
     104           1 : decltype(auto) local_synchronous_action(Proxy&& proxy, Args&&... args) {
     105             :   return Parallel::local_branch(proxy)
     106             :       ->template local_synchronous_action<Action>(std::forward<Args>(args)...);
     107             : }
     108             : 
     109             : /// @{
     110             : /*!
     111             :  * \ingroup ParallelGroup
     112             :  * \brief Invoke a threaded action on `proxy`, where the proxy must be a
     113             :  * nodegroup.
     114             :  */
     115             : template <typename Action, typename Proxy>
     116           1 : void threaded_action(Proxy&& proxy) {
     117             :   proxy.template threaded_action<Action>();
     118             : }
     119             : 
     120             : template <typename Action, typename Proxy, typename Arg0, typename... Args>
     121           1 : void threaded_action(Proxy&& proxy, Arg0&& arg0, Args&&... args) {
     122             :   proxy.template threaded_action<Action>(
     123             :       std::tuple<std::decay_t<Arg0>, std::decay_t<Args>...>(
     124             :           std::forward<Arg0>(arg0), std::forward<Args>(args)...));
     125             : }
     126             : /// @}
     127             : }  // namespace Parallel