Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <charm++.h>
       7             : #include <cstddef>
       8             : #include <limits>
       9             : #include <pup.h>
      10             : #include <string>
      11             : #include <unordered_map>
      12             : 
      13             : #include "Domain/Structure/ElementId.hpp"
      14             : #include "Parallel/NodeLock.hpp"
      15             : #include "Parallel/Phase.hpp"
      16             : #include "Utilities/Gsl.hpp"
      17             : #include "Utilities/Serialization/CharmPupable.hpp"
      18             : 
      19             : namespace Parallel {
      20             : /*!
      21             :  * \brief The base class of a member of an DG element array/map on a nodegroup.
      22             :  *
      23             :  * The nodegroup DgElementCollection stores all the elements on a node. Each
      24             :  * of those elements is a `DgElementArrayMember` and has this base class to
      25             :  * make access easier so it can be used in a type-erased context since
      26             :  * `DgElementArrayMember` depends on the metavariables,
      27             :  * phase-dependent-action-list, and the simple tags needed from options.
      28             :  *
      29             :  * This class essentially mimicks a lot of the functionality of
      30             :  * `Parallel::DistributedObject` but does not involve Charm++ beyond
      31             :  * serialization.
      32             :  */
      33             : template <size_t Dim>
      34           1 : class DgElementArrayMemberBase : PUP::able {
      35             :  public:
      36           0 :   DgElementArrayMemberBase() = default;
      37             : 
      38           0 :   DgElementArrayMemberBase(const DgElementArrayMemberBase& /*rhs*/) = default;
      39           0 :   DgElementArrayMemberBase& operator=(const DgElementArrayMemberBase& /*rhs*/) =
      40             :       default;
      41           0 :   DgElementArrayMemberBase(DgElementArrayMemberBase&& /*rhs*/) = default;
      42           0 :   DgElementArrayMemberBase& operator=(DgElementArrayMemberBase&& /*rhs*/) =
      43             :       default;
      44           0 :   ~DgElementArrayMemberBase() override = default;
      45             : 
      46           0 :   WRAPPED_PUPable_abstract(DgElementArrayMemberBase);  // NOLINT
      47             : 
      48           0 :   explicit DgElementArrayMemberBase(CkMigrateMessage* msg);
      49             : 
      50             :   /// Start execution of the phase-dependent action list in `next_phase`. If
      51             :   /// `next_phase` has already been visited, execution will resume at the point
      52             :   /// where the previous execution of the same phase left off.
      53             :   ///
      54             :   /// If \p force is true, then regardless of how this component terminated
      55             :   /// (error or deadlock), it will resume.
      56             :   ///
      57             :   /// \warning Don't set \p force to true unless you are absolutely sure you
      58             :   /// want to. This can have very unintended consequences if used incorrectly.
      59           1 :   virtual void start_phase(Parallel::Phase next_phase, bool force = false) = 0;
      60             : 
      61             :   /// Get the current phase
      62           1 :   Parallel::Phase phase() const;
      63             : 
      64             :   /// Tell the Algorithm it should no longer execute the algorithm. This does
      65             :   /// not mean that the execution of the program is terminated, but only that
      66             :   /// the algorithm has terminated. An algorithm can be restarted by passing
      67             :   /// `true` as the second argument to the `receive_data` method or by calling
      68             :   /// perform_algorithm(true).
      69           1 :   void set_terminate(gsl::not_null<size_t*> number_of_elements_terminated,
      70             :                      gsl::not_null<Parallel::NodeLock*> nodegroup_lock,
      71             :                      bool terminate);
      72             : 
      73             :   /// Check if an algorithm should continue being evaluated
      74           1 :   bool get_terminate() const;
      75             : 
      76             :   /// The zero-indexed step in the algorithm.
      77           1 :   size_t algorithm_step() const;
      78             : 
      79             :   /// Start evaluating the algorithm until it is stopped by an action.
      80           1 :   virtual void perform_algorithm() = 0;
      81             : 
      82             :   /// Print the expanded type aliases
      83           1 :   virtual std::string print_types() const = 0;
      84             : 
      85             :   /// Print the current state of the algorithm
      86           1 :   std::string print_state() const;
      87             : 
      88             :   /// Print the current contents of the inboxes
      89           1 :   virtual std::string print_inbox() const = 0;
      90             : 
      91             :   /// Print the current contents of the DataBox
      92           1 :   virtual std::string print_databox() const = 0;
      93             : 
      94             :   /// \brief The `inbox_lock()` only locks the inbox, nothing else. The inbox is
      95             :   /// unsafe to access without this lock.
      96             :   ///
      97             :   /// Use `element_lock()` to lock the rest of the element.
      98             :   ///
      99             :   /// This should always be managed by `std::unique_lock` or `std::lock_guard`.
     100           1 :   Parallel::NodeLock& inbox_lock();
     101             : 
     102             :   /// \brief Locks the element, except for the inbox, which is guarded by the
     103             :   /// `inbox_lock()`.
     104             :   ///
     105             :   /// This should always be managed by `std::unique_lock` or `std::lock_guard`.
     106           1 :   Parallel::NodeLock& element_lock();
     107             : 
     108             :   /// \brief Set which core this element should pretend to be bound to.
     109           1 :   void set_core(size_t core);
     110             : 
     111             :   /// \brief Get which core this element should pretend to be bound to.
     112           1 :   size_t get_core() const;
     113             : 
     114             :   /// Returns the name of the last "next iterable action" to be run before a
     115             :   /// deadlock occurred.
     116           1 :   const std::string& deadlock_analysis_next_iterable_action() const {
     117             :     return deadlock_analysis_next_iterable_action_;
     118             :   }
     119             : 
     120           0 :   void pup(PUP::er& p) override;
     121             : 
     122             :  protected:
     123           0 :   DgElementArrayMemberBase(ElementId<Dim> element_id, size_t node_number);
     124             : 
     125           0 :   Parallel::NodeLock inbox_lock_{};
     126           0 :   Parallel::NodeLock element_lock_{};
     127           0 :   bool performing_action_ = false;
     128           0 :   Parallel::Phase phase_{Parallel::Phase::Initialization};
     129           0 :   std::unordered_map<Parallel::Phase, size_t> phase_bookmarks_{};
     130           0 :   std::size_t algorithm_step_ = 0;
     131             : 
     132           0 :   bool terminate_{true};
     133           0 :   bool halt_algorithm_until_next_phase_{false};
     134             : 
     135             :   // Records the name of the next action to be called so that during deadlock
     136             :   // analysis we can print this out.
     137           0 :   std::string deadlock_analysis_next_iterable_action_{};
     138           0 :   ElementId<Dim> element_id_;
     139           0 :   size_t my_node_{std::numeric_limits<size_t>::max()};
     140             :   // There is no associated core. However, we use this as a method of
     141             :   // interoperating with core-aware concepts like the interpolation
     142             :   // framework. Once that framework is core-agnostic we will remove my_core_.
     143           0 :   size_t my_core_{std::numeric_limits<size_t>::max()};
     144             : };
     145             : }  // namespace Parallel