Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <string>
       7             : #include <tuple>
       8             : #include <vector>
       9             : 
      10             : #include "DataStructures/DataBox/DataBox.hpp"
      11             : #include "IO/Observer/ObserverComponent.hpp"
      12             : #include "IO/Observer/ReductionActions.hpp"
      13             : #include "Parallel/GlobalCache.hpp"
      14             : #include "Parallel/Invoke.hpp"
      15             : #include "Utilities/GetOutput.hpp"
      16             : #include "Utilities/Numeric.hpp"
      17             : 
      18             : namespace mem_monitor {
      19             : /*!
      20             :  * \brief Simple action meant to be used as a callback for
      21             :  * Parallel::contribute_to_reduction that writes the size of an Array parallel
      22             :  * component to disk.
      23             :  *
      24             :  * \details The columns in the dat file when running on 3 nodes will be
      25             :  *
      26             :  * - %Time
      27             :  * - Size on node 0 (MB)
      28             :  * - Size on node 1 (MB)
      29             :  * - Size on node 2 (MB)
      30             :  * - Average size per node (MB)
      31             :  *
      32             :  * The dat file will be placed in the `/MemoryMonitors/` group in the reduction
      33             :  * file. The name of the dat file is the `pretty_type::name` of the component.
      34             :  */
      35             : template <typename ArrayComponent>
      36           1 : struct ProcessArray {
      37             :   template <typename ParallelComponent, typename DbTags, typename Metavariables,
      38             :             typename ArrayIndex>
      39           0 :   static void apply(db::DataBox<DbTags>& /*box*/,
      40             :                     Parallel::GlobalCache<Metavariables>& cache,
      41             :                     const ArrayIndex& /*array_index*/, const double time,
      42             :                     const std::vector<double>& size_per_node) {
      43             :     auto& observer_writer_proxy = Parallel::get_parallel_component<
      44             :         observers::ObserverWriter<Metavariables>>(cache);
      45             : 
      46             :     std::vector<std::string> legend{{"Time"}};
      47             :     for (size_t i = 0; i < size_per_node.size(); i++) {
      48             :       legend.emplace_back("Size on node " + get_output(i) + " (MB)");
      49             :     }
      50             :     legend.emplace_back("Average size per node (MB)");
      51             : 
      52             :     const double avg_size = alg::accumulate(size_per_node, 0.0) /
      53             :                             static_cast<double>(size_per_node.size());
      54             : 
      55             :     Parallel::threaded_action<
      56             :         observers::ThreadedActions::WriteReductionDataRow>(
      57             :         // Node 0 is always the writer
      58             :         observer_writer_proxy[0], subfile_name<ArrayComponent>(), legend,
      59             :         std::make_tuple(time, size_per_node, avg_size));
      60             :   }
      61             : };
      62             : }  // namespace mem_monitor