Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines functions that provide low-level system information such as number
       6             : /// of nodes and processors, in a way that they are mockable in ActionTesting.
       7             : 
       8             : #pragma once
       9             : 
      10             : #include <cstddef>
      11             : 
      12             : /// Functionality for parallelization.
      13             : ///
      14             : /// The functions in namespace `Parallel` that return information on
      15             : /// nodes and cores are templated on DistribObject.  Actions should
      16             : /// use these functions rather than the raw charm++ versions (in the
      17             : /// sys namespace in Utilities/System/ParallelInfo.hpp) so that the
      18             : /// mocking framework will see the mocked cores and nodes.
      19             : namespace Parallel {
      20             : 
      21             : /*!
      22             :  * \ingroup ParallelGroup
      23             :  * \brief Number of processing elements.
      24             :  */
      25             : template <typename T, typename DistribObject>
      26           1 : T number_of_procs(const DistribObject& distributed_object) {
      27             :   return static_cast<T>(distributed_object.number_of_procs());
      28             : }
      29             : 
      30             : /*!
      31             :  * \ingroup ParallelGroup
      32             :  * \brief %Index of my processing element.
      33             :  */
      34             : template <typename T, typename DistribObject>
      35           1 : T my_proc(const DistribObject& distributed_object) {
      36             :   return static_cast<T>(distributed_object.my_proc());
      37             : }
      38             : 
      39             : /*!
      40             :  * \ingroup ParallelGroup
      41             :  * \brief Number of nodes.
      42             :  */
      43             : template <typename T, typename DistribObject>
      44           1 : T number_of_nodes(const DistribObject& distributed_object) {
      45             :   return static_cast<T>(distributed_object.number_of_nodes());
      46             : }
      47             : 
      48             : /*!
      49             :  * \ingroup ParallelGroup
      50             :  * \brief %Index of my node.
      51             :  */
      52             : template <typename T, typename DistribObject>
      53           1 : T my_node(const DistribObject& distributed_object) {
      54             :   return static_cast<T>(distributed_object.my_node());
      55             : }
      56             : 
      57             : /*!
      58             :  * \ingroup ParallelGroup
      59             :  * \brief Number of processing elements on the given node.
      60             :  */
      61             : template <typename T, typename R, typename DistribObject>
      62           1 : T procs_on_node(const R node_index, const DistribObject& distributed_object) {
      63             :   return static_cast<T>(
      64             :       distributed_object.procs_on_node(static_cast<int>(node_index)));
      65             : }
      66             : 
      67             : /*!
      68             :  * \ingroup ParallelGroup
      69             :  * \brief The local index of my processing element on my node.
      70             :  * This is in the interval 0, ..., procs_on_node(my_node()) - 1.
      71             :  */
      72             : template <typename T, typename DistribObject>
      73           1 : T my_local_rank(const DistribObject& distributed_object) {
      74             :   return static_cast<T>(distributed_object.my_local_rank());
      75             : }
      76             : 
      77             : /*!
      78             :  * \ingroup ParallelGroup
      79             :  * \brief %Index of first processing element on the given node.
      80             :  */
      81             : template <typename T, typename R, typename DistribObject>
      82           1 : T first_proc_on_node(const R node_index,
      83             :                      const DistribObject& distributed_object) {
      84             :   return static_cast<T>(
      85             :       distributed_object.first_proc_on_node(static_cast<int>(node_index)));
      86             : }
      87             : 
      88             : /*!
      89             :  * \ingroup ParallelGroup
      90             :  * \brief %Index of the node for the given processing element.
      91             :  */
      92             : template <typename T, typename R, typename DistribObject>
      93           1 : T node_of(const R proc_index, const DistribObject& distributed_object) {
      94             :   return static_cast<T>(
      95             :       distributed_object.node_of(static_cast<int>(proc_index)));
      96             : }
      97             : 
      98             : /*!
      99             :  * \ingroup ParallelGroup
     100             :  * \brief The local index for the given processing element on its node.
     101             :  */
     102             : template <typename T, typename R, typename DistribObject>
     103           1 : T local_rank_of(const R proc_index, const DistribObject& distributed_object) {
     104             :   return static_cast<T>(
     105             :       distributed_object.local_rank_of(static_cast<int>(proc_index)));
     106             : }
     107             : }  // namespace Parallel