Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <boost/functional/hash.hpp>
       7              : #include <ckarrayindex.h>
       8              : #include <cstddef>
       9              : #include <functional>
      10              : #include <string>
      11              : #include <type_traits>
      12              : 
      13              : #include "Parallel/ArrayIndex.hpp"
      14              : #include "Utilities/PrettyType.hpp"
      15              : 
      16              : namespace PUP {
      17              : class er;
      18              : }  // namespace PUP
      19              : 
      20              : namespace Parallel {
      21              : /*!
      22              :  * \brief An ID type that identifies both the parallel component and the index
      23              :  * in the parallel component.
      24              :  *
      25              :  * A specialization of `std::hash` is provided to allow using `ArrayComponentId`
      26              :  * as a key in associative containers.
      27              :  */
      28            1 : class ArrayComponentId {
      29              :  public:
      30            0 :   ArrayComponentId() = default;  // Needed for Charm++ serialization
      31              : 
      32              :   template <typename ParallelComponent>
      33            0 :   ArrayComponentId(const ParallelComponent* /*meta*/,
      34              :                    const CkArrayIndex& index);
      35              : 
      36              :   // NOLINTNEXTLINE(google-runtime-references)
      37            0 :   void pup(PUP::er& p);
      38              : 
      39            0 :   size_t component_id() const { return component_id_; }
      40              : 
      41            0 :   const CkArrayIndex& array_index() const { return array_index_; }
      42              : 
      43              :  private:
      44            0 :   size_t component_id_{0};
      45            0 :   CkArrayIndex array_index_{};
      46              : };
      47              : 
      48              : template <typename ParallelComponent>
      49              : ArrayComponentId::ArrayComponentId(const ParallelComponent* const /*meta*/,
      50              :                                    const CkArrayIndex& index)
      51              :     : array_index_(index) {
      52              :   // Hashing the pretty name demangles it, which is very expensive for the
      53              :   // long template names of parallel components. Since the result is the same
      54              :   // for every instance of `ParallelComponent`, compute it only once.
      55              :   static const size_t cached_component_id =
      56              :       std::hash<std::string>{}(pretty_type::get_name<ParallelComponent>());
      57              :   component_id_ = cached_component_id;
      58              : }
      59              : 
      60            0 : bool operator==(const ArrayComponentId& lhs, const ArrayComponentId& rhs);
      61              : 
      62            0 : bool operator!=(const ArrayComponentId& lhs, const ArrayComponentId& rhs);
      63              : 
      64            0 : std::ostream& operator<<(std::ostream& os,
      65              :                          const ArrayComponentId& array_component_id);
      66              : 
      67              : /*!
      68              :  * \brief A convenience function that will make an `ArrayComponentId` from the
      69              :  * templated `ParallelComponent` and the passed in `array_index`.
      70              :  */
      71              : template <typename ParallelComponent, typename ArrayIndexType>
      72            1 : ArrayComponentId make_array_component_id(const ArrayIndexType& array_index) {
      73              :   return ArrayComponentId{std::add_pointer_t<ParallelComponent>{nullptr},
      74              :                           Parallel::ArrayIndex<ArrayIndexType>(array_index)};
      75              : }
      76              : }  // namespace Parallel
      77              : 
      78              : namespace std {
      79              : template <>
      80              : struct hash<Parallel::ArrayComponentId> {
      81              :   size_t operator()(const Parallel::ArrayComponentId& t) const {
      82              :     size_t result = t.component_id();
      83              :     boost::hash_combine(result, t.array_index().hash());
      84              :     return result;
      85              :   }
      86              : };
      87              : }  // namespace std