Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <type_traits>
       7             : 
       8             : #include "DataStructures/DataBox/DataBox.hpp"
       9             : #include "Parallel/GlobalCache.hpp"
      10             : #include "Parallel/Info.hpp"
      11             : #include "Parallel/Invoke.hpp"
      12             : #include "Parallel/Local.hpp"
      13             : #include "Parallel/MemoryMonitor/MemoryMonitor.hpp"
      14             : #include "Parallel/TypeTraits.hpp"
      15             : #include "Utilities/Serialization/Serialize.hpp"
      16             : 
      17             : namespace mem_monitor {
      18             : /*!
      19             :  * \brief Simple action meant to be run on every branch of a Group or NodeGroup
      20             :  * that computes the size of the local branch and reports that size to the
      21             :  * MemoryMonitor using the ContributeMemoryData simple action.
      22             :  */
      23           1 : struct ProcessGroups {
      24             :   template <typename ParallelComponent, typename DbTags, typename Metavariables,
      25             :             typename ArrayIndex>
      26           0 :   static void apply(db::DataBox<DbTags>& /*box*/,
      27             :                     Parallel::GlobalCache<Metavariables>& cache,
      28             :                     const ArrayIndex& array_index, const double time) {
      29             :     static_assert(Parallel::is_group_v<ParallelComponent> or
      30             :                       Parallel::is_nodegroup_v<ParallelComponent>,
      31             :                   "ProcessGroups can only be run on Group or Nodegroup "
      32             :                   "parallel components.");
      33             :     static_assert(std::is_same_v<ArrayIndex, int>,
      34             :                   "ArrayIndex of Group or Nodegroup parallel components must "
      35             :                   "be an int to use the ProcessGroups action.");
      36             : 
      37             :     auto& singleton_proxy =
      38             :         Parallel::get_parallel_component<MemoryMonitor<Metavariables>>(cache);
      39             : 
      40             :     auto& group_proxy =
      41             :         Parallel::get_parallel_component<ParallelComponent>(cache);
      42             : 
      43             :     const double size_in_bytes = static_cast<double>(
      44             :         size_of_object_in_bytes(*Parallel::local_branch(group_proxy)));
      45             : 
      46             :     const double size_in_MB = size_in_bytes / 1.0e6;
      47             : 
      48             :     // Note that we don't call Parallel::contribute_to_reduction here. This is
      49             :     // because Charm requires that all calls to contribute_to_reduction happen
      50             :     // in the exact same order every time, otherwise it is undefined behavior.
      51             :     // However, this simple action (ProcessGroups) is called on each branch
      52             :     // of a group or nodegroup. Because this is a simple action, the order that
      53             :     // the branches run the simple actions is completely random based on
      54             :     // communication patterns in charm. Thus, calling contribute_to_reduction
      55             :     // here would result in undefined behavior.
      56             :     // Also note that `array_index` here is my_node for nodegroups and my_proc
      57             :     // for groups
      58             :     Parallel::simple_action<ContributeMemoryData<ParallelComponent>>(
      59             :         singleton_proxy, time, array_index, size_in_MB);
      60             :   }
      61             : };
      62             : }  // namespace mem_monitor