Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <array>
       7             : #include <cstddef>
       8             : #include <mutex>
       9             : #include <optional>
      10             : #include <type_traits>
      11             : #include <utility>
      12             : 
      13             : #include "Utilities/ErrorHandling/Error.hpp"
      14             : #include "Utilities/Gsl.hpp"
      15             : #include "Utilities/StaticCache.hpp"
      16             : #include "Utilities/TypeTraits/IsInteger.hpp"
      17             : 
      18             : /// \ingroup UtilitiesGroup
      19             : /// A cache that selects and lazily initializes entries at runtime.
      20             : ///
      21             : /// Unlike `StaticCache`, this class does not instantiate the generator once for
      22             : /// every combination of indices. This reduces compile time for large caches at
      23             : /// the cost of runtime index calculation and synchronization.
      24             : ///
      25             : /// \note `RuntimeCache` is tested in `Test_StaticCache.cpp`.
      26             : template <typename Generator, typename T, typename... Ranges>
      27           1 : class RuntimeCache {
      28             :  public:
      29           0 :   explicit RuntimeCache(Generator generator)
      30             :       : generator_{std::move(generator)} {}
      31             : 
      32             :   template <typename... Args>
      33           0 :   const T& operator()(const Args... parameters) const {
      34             :     static_assert(sizeof...(parameters) == sizeof...(Ranges),
      35             :                   "Number of arguments must match number of ranges.");
      36             :     size_t array_location = 0;
      37             :     ((array_location = array_location * static_cast<size_t>(Ranges::size) +
      38             :                        index<Ranges>(parameters)),
      39             :      ...);
      40             :     std::call_once(gsl::at(initialized_, array_location), [this, array_location,
      41             :                                                            &parameters...]() {
      42             :       gsl::at(cached_objects_, array_location)
      43             :           .emplace(generator_(
      44             :               static_cast<typename Ranges::value_type>(parameters)...));
      45             :     });
      46             :     return gsl::at(cached_objects_, array_location).value();
      47             :   }
      48             : 
      49             :  private:
      50             :   template <typename Range, typename U>
      51           0 :   static size_t index(const U parameter) {
      52             :     if constexpr (std::is_enum_v<U>) {
      53             :       static_assert(
      54             :           std::is_same_v<typename Range::value_type, std::remove_cv_t<U>>,
      55             :           "Mismatched enum parameter type and cached type.");
      56             :       for (size_t i = 0; i < Range::size; ++i) {
      57             :         if (parameter == gsl::at(Range::values, i)) {
      58             :           return i;
      59             :         }
      60             :       }
      61             :       ERROR("Uncached enumeration value: " << parameter);
      62             :     } else {
      63             :       static_assert(
      64             :           tt::is_integer_v<std::remove_cv_t<U>>,
      65             :           "The parameter passed for a CacheRange must be an integer type.");
      66             :       if (UNLIKELY(
      67             :               Range::start > static_cast<decltype(Range::start)>(parameter) or
      68             :               static_cast<decltype(Range::start)>(parameter) >= Range::end)) {
      69             :         ERROR("Index out of range: " << Range::start << " <= " << parameter
      70             :                                      << " < " << Range::end);
      71             :       }
      72             :       return static_cast<size_t>(
      73             :           static_cast<typename Range::value_type>(parameter) - Range::start);
      74             :     }
      75             :   }
      76             : 
      77           0 :   static constexpr size_t number_of_entries =
      78             :       (size_t{1} * ... * static_cast<size_t>(Ranges::size));
      79           0 :   Generator generator_;
      80             :   // NOLINTNEXTLINE(spectre-mutable)
      81           0 :   mutable std::array<std::once_flag, number_of_entries> initialized_{};
      82             :   // NOLINTNEXTLINE(spectre-mutable)
      83           0 :   mutable std::array<std::optional<T>, number_of_entries> cached_objects_{};
      84             : };
      85             : 
      86             : /// \ingroup UtilitiesGroup
      87             : /// Create a RuntimeCache, inferring the cached type from the generator.
      88             : template <typename... Ranges, typename Generator>
      89           1 : auto make_runtime_cache(Generator&& generator) {
      90             :   using CachedType = std::remove_cvref_t<decltype(generator(
      91             :       std::declval<typename Ranges::value_type>()...))>;
      92             :   return RuntimeCache<std::remove_cvref_t<Generator>, CachedType, Ranges...>(
      93             :       std::forward<Generator>(generator));
      94             : }