Change TerminatePhase return value

src/ParallelAlgorithms/Actions/CMakeLists.txt

@@ -18,6 +18,7 @@ spectre_target_headers(
   InitializeItems.hpp
   LimiterActions.hpp
   MutateApply.hpp
+  PausePhase.hpp
   RandomizeVariables.hpp
   SetData.hpp
   TerminatePhase.hpp

src/ParallelAlgorithms/Actions/PausePhase.hpp

@@ -0,0 +1,44 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#pragma once
+
+#include <optional>
+
+#include "Parallel/AlgorithmExecution.hpp"
+
+/// \cond
+namespace tuples {
+template <typename... InboxTags>
+struct TaggedTuple;
+}  // namespace tuples
+namespace Parallel {
+template <typename Metavariables>
+class GlobalCache;
+}  // namespace Parallel
+/// \endcond
+
+namespace Parallel::Actions {
+
+/*!
+ * \ingroup ActionsGroup
+ * \brief Pause the algorithm by returning
+ * `Parallel::AlgorithmExecution::Pause`.
+ */
+struct PausePhase {
+  template <typename DataBox, typename... InboxTags, typename Metavariables,
+            typename ArrayIndex, typename ActionList,
+            typename ParallelComponent>
+  static Parallel::iterable_action_return_t apply(
+      DataBox& /*box*/, const tuples::TaggedTuple<InboxTags...>& /*inboxes*/,
+      const Parallel::GlobalCache<Metavariables>& /*cache*/,
+      const ArrayIndex& /*array_index*/,
+      // NOLINTNEXTLINE(readability-avoid-const-params-in-decls)
+      const ActionList /*meta*/,
+      // NOLINTNEXTLINE(readability-avoid-const-params-in-decls)
+      const ParallelComponent* const /*meta*/) {
+    return {Parallel::AlgorithmExecution::Pause, std::nullopt};
+  }
+};
+
+}  // namespace Parallel::Actions

src/ParallelAlgorithms/Actions/TerminatePhase.hpp

@@ -18,12 +18,12 @@ class GlobalCache;
 }  // namespace Parallel
 /// \endcond
 
-namespace Parallel {
-namespace Actions {
+namespace Parallel::Actions {
 
 /*!
  * \ingroup ActionsGroup
- * \brief Terminate the algorithm to proceed to the next phase.
+ * \brief Halt the algorithm and wait to proceed to the next phase by returning
+ * `Parallel::AlgorithmExecution::Halt`
  */
 struct TerminatePhase {
   template <typename DataBox, typename... InboxTags, typename Metavariables,
@@ -37,9 +37,8 @@ struct TerminatePhase {
       const ActionList /*meta*/,
       // NOLINTNEXTLINE(readability-avoid-const-params-in-decls)
       const ParallelComponent* const /*meta*/) {
-    return {Parallel::AlgorithmExecution::Pause, std::nullopt};
+    return {Parallel::AlgorithmExecution::Halt, std::nullopt};
   }
 };
 
-}  // namespace Actions
-}  // namespace Parallel
+}  // namespace Parallel::Actions

tests/Unit/Elliptic/DiscontinuousGalerkin/SubdomainOperator/Test_SubdomainOperator.cpp

@@ -61,6 +61,7 @@
 #include "Parallel/Phase.hpp"
 #include "Parallel/PhaseDependentActionList.hpp"
 #include "ParallelAlgorithms/Actions/InitializeItems.hpp"
+#include "ParallelAlgorithms/Actions/PausePhase.hpp"
 #include "ParallelAlgorithms/Actions/SetData.hpp"
 #include "ParallelAlgorithms/Actions/TerminatePhase.hpp"
 #include "ParallelAlgorithms/Amr/Actions/Component.hpp"
@@ -437,16 +438,16 @@ struct ElementArray {
                   Dim, subdomain_init_tags, DummyOptionsGroup, false,
                   TemporalIdTag>,
               init_subdomain_action, init_random_subdomain_data_action,
-              Parallel::Actions::TerminatePhase,
+              Parallel::Actions::PausePhase,
               // Full DG operator
               typename dg_operator::apply_actions,
-              Parallel::Actions::TerminatePhase,
+              Parallel::Actions::PausePhase,
               // Subdomain operator
               ApplySubdomainOperator<SubdomainOperator,
                                      typename fields_tag::tags_list>,
               TestSubdomainOperatorMatrix<SubdomainOperator,
                                           typename fields_tag::tags_list>,
-              Parallel::Actions::TerminatePhase>>>;
+              Parallel::Actions::PausePhase>>>;
 };
 
 template <typename Metavariables>
@@ -605,8 +606,7 @@ void test_subdomain_operator(
           {initial_ref_levs, initial_extents, SubdomainOperator{},
            typename subdomain_operator_applied_to_fields_tag::type{},
            override_boundary_conditions});
-      while (
-          not ActionTesting::get_terminate<element_array>(runner, element_id)) {
+      for (size_t i = 0; i < 4 + tmpl::size<ExtraInitActions>::value; i++) {
         ActionTesting::next_action<element_array>(make_not_null(&runner),
                                                   element_id);
       }

tests/Unit/Elliptic/DiscontinuousGalerkin/Test_DgOperator.cpp

@@ -46,6 +46,7 @@
 #include "Parallel/Phase.hpp"
 #include "ParallelAlgorithms/Actions/Goto.hpp"
 #include "ParallelAlgorithms/Actions/InitializeItems.hpp"
+#include "ParallelAlgorithms/Actions/PausePhase.hpp"
 #include "ParallelAlgorithms/Actions/SetData.hpp"
 #include "ParallelAlgorithms/Actions/TerminatePhase.hpp"
 #include "ParallelAlgorithms/Amr/Actions/Component.hpp"
@@ -156,7 +157,7 @@ struct ElementArray {
                              System, fixed_sources_tag>,
                      ::Actions::Label<ApplyOperatorStart>,
                      typename dg_operator::apply_actions, IncrementTemporalId,
-                     Parallel::Actions::TerminatePhase>>>;
+                     Parallel::Actions::PausePhase>>>;
 };
 
 template <typename Metavariables>

tests/Unit/Evolution/Systems/Cce/Actions/Test_AnalyticBoundaryCommunication.cpp

@@ -209,10 +209,10 @@ SPECTRE_TEST_CASE(
           std::make_unique<::TimeSteppers::DormandPrince5>()));
 
   // Run the initializations
-  for (size_t i = 0; i < 6; ++i) {
+  for (size_t i = 0; i < 5; ++i) {
     ActionTesting::next_action<evolution_component>(make_not_null(&runner), 0);
   }
-  for (size_t i = 0; i < 3; ++i) {
+  for (size_t i = 0; i < 2; ++i) {
     ActionTesting::next_action<worldtube_component>(make_not_null(&runner), 0);
   }
   runner.set_phase(Parallel::Phase::Evolve);

tests/Unit/Evolution/Systems/Cce/Actions/Test_H5BoundaryCommunication.cpp

@@ -257,10 +257,10 @@ SPECTRE_TEST_CASE("Unit.Evolution.Systems.Cce.Actions.H5BoundaryCommunication",
           false, false, std::optional<double>{}));
 
   // this should run the initializations
-  for (size_t i = 0; i < 5; ++i) {
+  for (size_t i = 0; i < 4; ++i) {
     ActionTesting::next_action<evolution_component>(make_not_null(&runner), 0);
   }
-  for (size_t i = 0; i < 2; ++i) {
+  for (size_t i = 0; i < 1; ++i) {
     ActionTesting::next_action<worldtube_component>(make_not_null(&runner), 0);
   }
   ActionTesting::set_phase(make_not_null(&runner), Parallel::Phase::Evolve);

tests/Unit/Evolution/Systems/Cce/Actions/Test_InitializeCharacteristicEvolution.cpp

@@ -198,7 +198,7 @@ SPECTRE_TEST_CASE(
       target_step_size, scri_plus_interpolation_order);
 
   // this should run the initialization
-  for (size_t i = 0; i < 6; ++i) {
+  for (size_t i = 0; i < 5; ++i) {
     ActionTesting::next_action<component>(make_not_null(&runner), 0);
   }
   ActionTesting::set_phase(make_not_null(&runner), Parallel::Phase::Evolve);

tests/Unit/Evolution/Systems/Cce/Actions/Test_InitializeKleinGordonCharacteristicEvolution.cpp

@@ -183,7 +183,7 @@ void test_klein_gordon_cce_initialization(const gsl::not_null<Generator*> gen) {
       target_step_size, scri_plus_interpolation_order);
 
   // go through the action list
-  for (size_t i = 0; i < 7; ++i) {
+  for (size_t i = 0; i < 6; ++i) {
     ActionTesting::next_action<component>(make_not_null(&runner), 0);
   }
   ActionTesting::set_phase(make_not_null(&runner), Parallel::Phase::Evolve);

tests/Unit/Evolution/Systems/Cce/Actions/Test_InitializeWorldtubeBoundary.cpp

@@ -128,7 +128,7 @@ void test_h5_initialization(const gsl::not_null<Generator*> gen) {
           false, false, std::optional<double>{}));
 
   // this should run the initialization
-  for (size_t i = 0; i < 3; ++i) {
+  for (size_t i = 0; i < 2; ++i) {
     ActionTesting::next_action<component>(make_not_null(&runner), 0);
   }
   ActionTesting::set_phase(make_not_null(&runner), Parallel::Phase::Evolve);
@@ -177,7 +177,7 @@ void test_gh_initialization() {
       InterfaceManagers::GhLockstep{});
 
   // this should run the initialization
-  for (size_t i = 0; i < 3; ++i) {
+  for (size_t i = 0; i < 2; ++i) {
     ActionTesting::next_action<component>(make_not_null(&runner), 0);
   }
   runner.set_phase(Parallel::Phase::Evolve);
@@ -210,7 +210,7 @@ void test_analytic_initialization() {
       static_cast<std::unique_ptr<TimeStepper>>(
           std::make_unique<::TimeSteppers::Rk3HesthavenSsp>()));
   // this should run the initialization
-  for (size_t i = 0; i < 3; ++i) {
+  for (size_t i = 0; i < 2; ++i) {
     ActionTesting::next_action<component>(make_not_null(&runner), 0);
   }
   runner.set_phase(Parallel::Phase::Evolve);

tests/Unit/Evolution/Systems/Cce/Actions/Test_InsertInterpolationScriData.cpp

@@ -289,7 +289,7 @@ SPECTRE_TEST_CASE(
   ActionTesting::emplace_component<MockObserver<test_metavariables>>(&runner,
                                                                      0);
   // the initialization actions
-  for (size_t i = 0; i < 6; ++i) {
+  for (size_t i = 0; i < 5; ++i) {
     ActionTesting::next_action<evolution_component>(make_not_null(&runner), 0);
   }
   runner.set_phase(Parallel::Phase::Evolve);

tests/Unit/Evolution/Systems/Cce/Actions/Test_KleinGordonH5BoundaryCommunication.cpp

@@ -236,10 +236,10 @@ void test_klein_gordon_h5_boundary_communication(
           std::optional<double>{}));
 
   // this should run the initializations
-  for (size_t i = 0; i < 6; ++i) {
+  for (size_t i = 0; i < 5; ++i) {
     ActionTesting::next_action<evolution_component>(make_not_null(&runner), 0);
   }
-  for (size_t i = 0; i < 2; ++i) {
+  for (size_t i = 0; i < 1; ++i) {
     ActionTesting::next_action<worldtube_component>(make_not_null(&runner), 0);
   }
 

tests/Unit/Evolution/Systems/Cce/Actions/Test_RequestBoundaryData.cpp

@@ -222,10 +222,10 @@ SPECTRE_TEST_CASE("Unit.Evolution.Systems.Cce.Actions.RequestBoundaryData",
           false, false, std::optional<double>{}));
 
   // this should run the initializations
-  for (size_t i = 0; i < 5; ++i) {
+  for (size_t i = 0; i < 4; ++i) {
     ActionTesting::next_action<evolution_component>(make_not_null(&runner), 0);
   }
-  for(size_t i = 0; i < 3; ++i) {
+  for (size_t i = 0; i < 2; ++i) {
     ActionTesting::next_action<worldtube_component>(make_not_null(&runner), 0);
   }
   ActionTesting::set_phase(make_not_null(&runner), Parallel::Phase::Evolve);

tests/Unit/Evolution/Systems/Cce/Actions/Test_RequestKleinGordonBoundaryData.cpp

@@ -204,7 +204,7 @@ void test_klein_gordon_boundary_data(const gsl::not_null<Generator*> gen) {
           std::optional<double>{}));
 
   // this should run the initializations
-  for (size_t i = 0; i < 6; ++i) {
+  for (size_t i = 0; i < 5; ++i) {
     ActionTesting::next_action<evolution_component>(make_not_null(&runner), 0);
   }
   for (size_t i = 0; i < 2; ++i) {

tests/Unit/ParallelAlgorithms/Actions/CMakeLists.txt

@@ -9,6 +9,7 @@ set(LIBRARY_SOURCES
   Test_Goto.cpp
   Test_InitializeItems.cpp
   Test_MutateApply.cpp
+  Test_PausePhase.cpp
   Test_RandomizeVariables.cpp
   Test_SetData.cpp
   Test_TerminatePhase.cpp

tests/Unit/ParallelAlgorithms/Actions/Test_PausePhase.cpp

@@ -0,0 +1,38 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#include "Framework/TestingFramework.hpp"
+
+#include "Framework/ActionTesting.hpp"
+#include "Parallel/Phase.hpp"
+#include "ParallelAlgorithms/Actions/PausePhase.hpp"
+#include "Utilities/TMPL.hpp"
+
+namespace {
+template <typename Metavariables>
+struct Component {
+  using metavariables = Metavariables;
+  using chare_type = ActionTesting::MockArrayChare;
+  using array_index = int;
+  using phase_dependent_action_list = tmpl::list<Parallel::PhaseActions<
+      Parallel::Phase::Testing, tmpl::list<Parallel::Actions::PausePhase>>>;
+};
+
+struct Metavariables {
+  using component_list = tmpl::list<Component<Metavariables>>;
+};
+}  // namespace
+
+SPECTRE_TEST_CASE("Unit.Parallel.Actions.PausePhase",
+                  "[Unit][Parallel][Actions]") {
+  using component = Component<Metavariables>;
+
+  ActionTesting::MockRuntimeSystem<Metavariables> runner{{}};
+  ActionTesting::emplace_component<component>(&runner, 0);
+
+  ActionTesting::set_phase(make_not_null(&runner), Parallel::Phase::Testing);
+
+  CHECK_FALSE(ActionTesting::get_terminate<component>(runner, 0));
+  ActionTesting::next_action<component>(make_not_null(&runner), 0);
+  CHECK(ActionTesting::get_terminate<component>(runner, 0));
+}

tests/Unit/Time/Actions/Test_SelfStartActions.cpp

@@ -25,6 +25,8 @@
 #include "Parallel/AlgorithmExecution.hpp"
 #include "Parallel/Phase.hpp"
 #include "Parallel/PhaseDependentActionList.hpp"
+#include "ParallelAlgorithms/Actions/PausePhase.hpp"
+#include "ParallelAlgorithms/Actions/TerminatePhase.hpp"
 #include "Time/Actions/CleanHistory.hpp"
 #include "Time/Actions/RecordTimeStepperData.hpp"
 #include "Time/Actions/SelfStartActions.hpp"
@@ -161,10 +163,15 @@ struct Component {
                  Actions::CleanHistory<typename metavariables::system, false>,
                  tmpl::conditional_t<has_primitives, Actions::UpdatePrimitives,
                                      tmpl::list<>>>;
-  using action_list = tmpl::flatten<
-      tmpl::list<SelfStart::self_start_procedure<
-                     step_actions, typename metavariables::system>,
-                 step_actions>>;
+  // This test doesn't operate exactly like how SelfStart would normally work in
+  // an executable. Instead it jumps around quite a lot. Therefore to avoid any
+  // issues that TerminatePhase would cause, we just replace it with PausePhase.
+  using action_list = tmpl::replace<
+      tmpl::flatten<
+          tmpl::list<SelfStart::self_start_procedure<
+                         step_actions, typename metavariables::system>,
+                     step_actions>>,
+      Parallel::Actions::TerminatePhase, Parallel::Actions::PausePhase>;
   using phase_dependent_action_list = tmpl::list<
       Parallel::PhaseActions<Parallel::Phase::Initialization,
                              tmpl::list<ActionTesting::InitializeDataBox<