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 <mutex>
       8             : #include <stdexcept>
       9             : 
      10             : #include "DataStructures/DataBox/DataBox.hpp"
      11             : #include "Domain/Structure/ElementId.hpp"
      12             : #include "Parallel/ArrayCollection/Tags/NumberOfElementsTerminated.hpp"
      13             : #include "Parallel/GlobalCache.hpp"
      14             : #include "Parallel/Local.hpp"
      15             : #include "Parallel/NodeLock.hpp"
      16             : #include "Utilities/ErrorHandling/Assert.hpp"
      17             : #include "Utilities/ErrorHandling/Error.hpp"
      18             : #include "Utilities/Gsl.hpp"
      19             : 
      20             : namespace Parallel::Actions {
      21             : /// \brief Set the element with ID `my_element_id` to be terminated. This is
      22             : /// always invoked on the local component via
      23             : /// `Parallel::local_synchronous_action`
      24             : ///
      25             : /// In the future we can use this to try and elide Charm++ calls when the
      26             : /// receiver is local.
      27           1 : struct SetTerminateOnElement {
      28           0 :   using return_type = void;
      29             : 
      30             :   template <typename ParallelComponent, typename DbTagList,
      31             :             typename Metavariables, size_t Dim>
      32           0 :   static return_type apply(
      33             :       db::DataBox<DbTagList>& box, gsl::not_null<Parallel::NodeLock*> node_lock,
      34             :       gsl::not_null<Parallel::GlobalCache<Metavariables>*> cache,
      35             :       const ElementId<Dim>& my_element_id, bool terminate_value);
      36             : };
      37             : 
      38             : template <typename ParallelComponent, typename DbTagList,
      39             :           typename Metavariables, size_t Dim>
      40           0 : auto SetTerminateOnElement::apply(
      41             :     db::DataBox<DbTagList>& box,
      42             :     const gsl::not_null<Parallel::NodeLock*> node_lock,
      43             :     const gsl::not_null<Parallel::GlobalCache<Metavariables>*> cache,
      44             :     const ElementId<Dim>& my_element_id, const bool terminate_value)
      45             :     -> return_type {
      46             :   std::lock_guard node_guard(*node_lock);
      47             :   db::mutate<typename ParallelComponent::element_collection_tag,
      48             :              Parallel::Tags::NumberOfElementsTerminated>(
      49             :       [&cache, &my_element_id, &node_lock, terminate_value](
      50             :           const auto element_collection_ptr,
      51             :           const auto num_terminated_ptr) -> void {
      52             :         try {
      53             :           // Note: The nodelock is checked by set_terminate as a sanity
      54             :           // check and as a way of making set_terminate difficult to use
      55             :           // without this action.
      56             :           //
      57             :           // Note: since this is a local synchronous action running on the
      58             :           // element that called it, we already have the element locked and so
      59             :           // setting terminate is threadsafe.
      60             :           //
      61             :           // Note: the element's set_terminate updates num_terminated
      62             :           // correctly so we don't need to handle that here.
      63             :           element_collection_ptr->at(my_element_id)
      64             :               .set_terminate(num_terminated_ptr, node_lock, terminate_value);
      65             : 
      66             :           // Update the state of the nodegroup. Specifically, if _all_
      67             :           // elements are set to be terminated, we terminate the nodegroup,
      68             :           // otherwise we do not.
      69             :           auto* local_branch = Parallel::local_branch(
      70             :               Parallel::get_parallel_component<ParallelComponent>(*cache));
      71             :           ASSERT(local_branch != nullptr,
      72             :                  "The local branch is nullptr, which is inconsistent");
      73             :           local_branch->set_terminate(*num_terminated_ptr ==
      74             :                                       element_collection_ptr->size());
      75             :         } catch (const std::out_of_range&) {
      76             :           ERROR("Could not find element with ID " << my_element_id
      77             :                                                   << " on node");
      78             :         }
      79             :       },
      80             :       make_not_null(&box));
      81             : }
      82             : }  // namespace Parallel::Actions