Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include "DataStructures/DataBox/Protocols/Mutator.hpp"
       7              : #include "Parallel/Algorithms/AlgorithmSingletonDeclarations.hpp"
       8              : #include "Parallel/GlobalCache.hpp"
       9              : #include "Parallel/Local.hpp"
      10              : #include "Parallel/MemoryMonitor/Tags.hpp"
      11              : #include "Parallel/ParallelComponentHelpers.hpp"
      12              : #include "Parallel/Phase.hpp"
      13              : #include "ParallelAlgorithms/Actions/AddSimpleTags.hpp"
      14              : #include "ParallelAlgorithms/Actions/TerminatePhase.hpp"
      15              : #include "Utilities/Gsl.hpp"
      16              : #include "Utilities/ProtocolHelpers.hpp"
      17              : #include "Utilities/TMPL.hpp"
      18              : 
      19              : /*!
      20              :  * \ingroup ParallelGroup
      21              :  * Holds the MemoryMonitor parallel component and all actions and tags related
      22              :  * to the memory monitor.
      23              :  */
      24            1 : namespace mem_monitor {}
      25              : 
      26              : namespace mem_monitor {
      27              : namespace detail {
      28              : struct InitializeMutator : tt::ConformsTo<db::protocols::Mutator> {
      29              :   using return_tags = tmpl::list<mem_monitor::Tags::MemoryHolder>;
      30              :   using argument_tags = tmpl::list<>;
      31              : 
      32              :   using tag_type = typename mem_monitor::Tags::MemoryHolder::type;
      33              : 
      34              :   static void apply(const gsl::not_null<tag_type*> /*holder*/) {}
      35              : };
      36              : }  // namespace detail
      37              : 
      38              : /*!
      39              :  * \brief Singleton parallel component used for monitoring memory usage of other
      40              :  * parallel components
      41              :  */
      42              : template <class Metavariables>
      43            1 : struct MemoryMonitor {
      44            0 :   using chare_type = Parallel::Algorithms::Singleton;
      45            0 :   static constexpr bool checkpoint_data = true;
      46              : 
      47            0 :   using metavariables = Metavariables;
      48              : 
      49            0 :   using phase_dependent_action_list = tmpl::list<Parallel::PhaseActions<
      50              :       Parallel::Phase::Initialization,
      51              :       tmpl::list<Initialization::Actions::AddSimpleTags<
      52              :                      mem_monitor::detail::InitializeMutator>,
      53              :                  Parallel::Actions::TerminatePhase>>>;
      54              : 
      55            0 :   using simple_tags_from_options = Parallel::get_simple_tags_from_options<
      56              :       Parallel::get_initialization_actions_list<phase_dependent_action_list>>;
      57              : 
      58            0 :   static void execute_next_phase(
      59              :       const Parallel::Phase next_phase,
      60              :       Parallel::CProxy_GlobalCache<Metavariables>& global_cache) {
      61              :     auto& local_cache = *Parallel::local_branch(global_cache);
      62              :     Parallel::get_parallel_component<MemoryMonitor<Metavariables>>(local_cache)
      63              :         .start_phase(next_phase);
      64              :   }
      65              : };
      66              : }  // namespace mem_monitor