Line data    Source code

       1            1 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : /// \file
       5              : /// This file should be included in each file which defines an array
       6              : /// parallel component; doing so ensures that the correct charm++ chares are
       7              : /// defined for executables that use that parallel component.
       8              : 
       9              : #pragma once
      10              : 
      11              : #include "Parallel/Algorithms/AlgorithmArrayDeclarations.hpp"
      12              : #include "Parallel/ArrayIndex.hpp"
      13              : #include "Parallel/DistributedObject.hpp"
      14              : 
      15              : /*!
      16              :  * \ingroup ParallelGroup
      17              :  * \brief A Spectre algorithm object that wraps a charm++ array chare.
      18              :  *
      19              :  * \details This object is the definition of the distributed charm++ object
      20              :  * associated with the SpECTRE component wrappers (see \ref
      21              :  * dev_guide_parallelization_foundations). See also the charm++ documentation:
      22              :  * https://charm.readthedocs.io/en/latest/charm++/manual.html#chare-arrays
      23              :  * When comparing against the implementations in the charm++ documentation, this
      24              :  * object is the one directly associated to declarations in the corresponding
      25              :  * `AlgorithmArray.ci` file.
      26              :  *
      27              :  * Unlike the techniques described in the charm++ documentation, however, we
      28              :  * define `AlgorithmArray` as a strong typedef so that the core functionality
      29              :  * can be shared between chare types by introducing an additional inheritance
      30              :  * layer. The documentation suggests the inheritance path `A -> CBase_A`, where
      31              :  * we have the inheritance path:
      32              :  * ```
      33              :  * AlgorithmArray -> DistributedObject -> CBase_AlgorithmArray
      34              :  * ```
      35              :  * That allows us to introduce the template class
      36              :  * <code><a href="classParallel_1_1DistributedObject_3_01ParallelComponent_00_01tmpl_1_1list_3_01PhaseDepActionListsPack_8_8_8_01_4_01_4.html">
      37              :  * Parallel::DistributedObject</a></code>
      38              :  * that handles all generalizable control-flow.
      39              :  */
      40              : // Note that the above manual link is needed because doxygen can't properly link
      41              : // template specializations, but we'd really like to link to the
      42              : // DistributedObject
      43              : template <typename ParallelComponent, typename SpectreArrayIndex>
      44            1 : class AlgorithmArray
      45              :     : public Parallel::DistributedObject<
      46              :           ParallelComponent,
      47              :           typename ParallelComponent::phase_dependent_action_list> {
      48            0 :   using algorithm = Parallel::Algorithms::Array;
      49              : 
      50              :  public:
      51              :   using Parallel::DistributedObject<
      52              :       ParallelComponent, typename ParallelComponent::
      53              :                              phase_dependent_action_list>::DistributedObject;
      54              : };
      55              : 
      56            0 : #define CK_TEMPLATES_ONLY
      57              : #include "Parallel/Algorithms/AlgorithmArray.def.h"
      58              : #undef CK_TEMPLATES_ONLY