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/Info.hpp"
      15             : #include "Parallel/Invoke.hpp"
      16             : #include "Parallel/Local.hpp"
      17             : #include "Utilities/Serialization/Serialize.hpp"
      18             : 
      19             : namespace mem_monitor {
      20             : /*!
      21             :  * \brief Simple action meant to be run on a Singleton that writes the size of
      22             :  * the Singleton component to disk.
      23             :  *
      24             :  * \details The columns in the dat file are
      25             :  *
      26             :  * - %Time
      27             :  * - Proc
      28             :  * - Size (MB)
      29             :  *
      30             :  * The dat file will be placed in the `/MemoryMonitors/` group in the reduction
      31             :  * file. The name of the dat file is the `pretty_type::name` of the component.
      32             :  */
      33           1 : struct ProcessSingleton {
      34             :   template <typename ParallelComponent, typename DbTags, typename Metavariables,
      35             :             typename ArrayIndex>
      36           0 :   static void apply(db::DataBox<DbTags>& /*box*/,
      37             :                     Parallel::GlobalCache<Metavariables>& cache,
      38             :                     const ArrayIndex& /*array_index*/, const double time) {
      39             :     static_assert(
      40             :         Parallel::is_singleton_v<ParallelComponent>,
      41             :         "ProcessSingleton can only be run on a Singleton parallel component.");
      42             :     auto& singleton_proxy =
      43             :         Parallel::get_parallel_component<ParallelComponent>(cache);
      44             :     const double size_in_bytes = static_cast<double>(
      45             :         size_of_object_in_bytes(*Parallel::local(singleton_proxy)));
      46             :     const double size_in_MB = size_in_bytes / 1.0e6;
      47             : 
      48             :     const std::vector<std::string> legend{{"Time", "Proc", "Size (MB)"}};
      49             : 
      50             :     auto& observer_writer_proxy = Parallel::get_parallel_component<
      51             :         observers::ObserverWriter<Metavariables>>(cache);
      52             : 
      53             :     Parallel::threaded_action<
      54             :         observers::ThreadedActions::WriteReductionDataRow>(
      55             :         // Node 0 is always the writer
      56             :         observer_writer_proxy[0], subfile_name<ParallelComponent>(), legend,
      57             :         std::make_tuple(
      58             :             time, Parallel::my_proc<size_t>(*Parallel::local(singleton_proxy)),
      59             :             size_in_MB));
      60             :   }
      61             : };
      62             : }  // namespace mem_monitor