Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <charm++.h>
       7              : #include <type_traits>
       8              : 
       9              : #include "Utilities/ErrorHandling/Assert.hpp"
      10              : #include "Utilities/TypeTraits/IsA.hpp"
      11              : 
      12              : namespace Parallel {
      13              : /*!
      14              :  * \ingroup ParallelGroup
      15              :  * \brief The array index used for indexing Chare Arrays, mostly an
      16              :  * implementation detail
      17              :  *
      18              :  * The implementation is generic and can handle custom array indices. This
      19              :  * replaces the generated, hard-coded Charm++ array indices with a template,
      20              :  * allowing a single implementation to be used for different array indices.
      21              :  *
      22              :  * \details Charm++ allocates memory for `CkArrayIndex`. The size can be
      23              :  * configured (in the Charm++ configuration) and defaults to the size of three
      24              :  * integers. We place the `Index` into this buffer using placement `new`. Then,
      25              :  * `CkArrayIndex::data()` can be safely reinterpreted as an `Index*`.
      26              :  */
      27              : template <class Index>
      28            1 : struct ArrayIndex : public CkArrayIndex {
      29              :   static_assert(std::is_standard_layout_v<Index> and std::is_trivial_v<Index>,
      30              :                 "The array index type must be a POD, plain-old-data");
      31              :   // clang-tidy: suspicious use of sizeof
      32              :   static_assert(sizeof(Index) <= 3 * sizeof(int),  // NOLINT
      33              :                 "The default Charm++ CK_ARRAYINDEX_MAXLEN is 3. If you have "
      34              :                 "changed this at Charm++ configuration time then please update "
      35              :                 "the static_assert, otherwise your Index type is too large.");
      36              :   // clang-tidy: suspicious use of sizeof
      37              :   static_assert(sizeof(Index) % sizeof(int) == 0,  // NOLINT
      38              :                 "The Charm++ array Index type must be exactly a multiple of "
      39              :                 "the size of an integer, but the user-provided one is not.");
      40              :   static_assert(
      41              :       alignof(Index) == alignof(decltype(index)),
      42              :       "Incorrect alignment of Charm++ array Index type. The "
      43              :       "alignment must match the alignment of the internal Charm++ type");
      44              :   static_assert(not tt::is_a_v<ArrayIndex, Index>,
      45              :                 "The Index type passed to ArrayIndex cannot be an ArrayIndex");
      46              : 
      47              :   // Use placement new to ensure that the custom index object is placed in the
      48              :   // memory reserved for it in the base class
      49              :   // clang-tidy: mark explicit: it's a conversion constructor
      50            0 :   ArrayIndex(const Index& array_index)  // NOLINT
      51              :                                         // clang-tidy: do not use unions
      52              :       : array_index_(new (index) Index(array_index)) {  // NOLINT
      53              :     // clang-tidy: suspicious use of sizeof
      54              :     nInts = sizeof(array_index) / sizeof(int);  // NOLINT
      55              :   }
      56              : 
      57              :   // clang-tidy: mark explicit: it's a conversion constructor
      58            0 :   ArrayIndex(const CkArrayIndex& array_index)  // NOLINT
      59              :       : CkArrayIndex(array_index),
      60              :         // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      61              :         array_index_(reinterpret_cast<Index*>(CkArrayIndex::data())) {
      62              :     ASSERT(CkArrayIndex::nInts * sizeof(int) == sizeof(Index),
      63              :            "The CkArrayIndex::nInts does not match the size of the custom "
      64              :            "array index class.");
      65              :   }
      66              : 
      67            0 :   ArrayIndex(const ArrayIndex& rhs) = delete;
      68            0 :   ArrayIndex& operator=(const ArrayIndex& rhs) = delete;
      69              : 
      70            0 :   ArrayIndex(ArrayIndex&& /*rhs*/) = delete;
      71            0 :   ArrayIndex& operator=(ArrayIndex&& /*rhs*/) = delete;
      72            0 :   ~ArrayIndex() = default;
      73              : 
      74            0 :   const Index& get_index() const { return *array_index_; }
      75              : 
      76              :  private:
      77            0 :   Index* array_index_ = nullptr;
      78              : };
      79              : 
      80            0 : using ArrayIndex1D = ArrayIndex<CkIndex1D>;
      81            0 : using ArrayIndex2D = ArrayIndex<CkIndex2D>;
      82            0 : using ArrayIndex3D = ArrayIndex<CkIndex3D>;
      83            0 : using ArrayIndex4D = ArrayIndex<CkIndex4D>;
      84            0 : using ArrayIndex5D = ArrayIndex<CkIndex5D>;
      85            0 : using ArrayIndex6D = ArrayIndex<CkIndex6D>;
      86              : }  // namespace Parallel
      87              : 
      88              : // These namespaces have silly names because we are subverting the charm++
      89              : // utilities that prepend "CkArrayIndex" to the name of the array index. See
      90              : // comments in Parallel/Algorithms/AlgorithmArray.ci for further explanation.
      91              : 
      92              : namespace CkArrayIndexSpectreIndex_detail {
      93              : template <typename Index>
      94              : using ArrayIndex = ::Parallel::ArrayIndex<Index>;
      95              : }  // namespace CkArrayIndexSpectreIndex_detail
      96              : 
      97              : namespace SpectreIndex_detail {
      98              : template <typename Index>
      99              : using ArrayIndex = Index;
     100              : }  // namespace SpectreIndex_detail