probe.hpp

#ifndef __CORE__PROBE_HPP__
#define __CORE__PROBE_HPP__
 
#include <Kokkos_Core.hpp>
#include <biocma_cst_config.hpp>
#include <cstddef>
#include <cstdint>
// #include <type_traits>
 
// template <typename ViewType, typename ExecutionSpace>
// KOKKOS_INLINE_FUNCTION bool is_view_accessible(const ViewType& view)
// {
//   return Kokkos::SpaceAccessibility<typename ExecutionSpace::memory_space,
//                                     typename ViewType::memory_space>::accessible;
// }
 
namespace Simulation
{
  template <std::size_t buffer_size> class Probes
  {
  public:
    void clear();
 
    [[nodiscard]] KOKKOS_INLINE_FUNCTION bool set(double val) const;
 
    [[nodiscard]] bool need_export() const noexcept;
 
    // [[nodiscard]] const double* raw_get() const;
 
    [[nodiscard]] std::span<const double> get() const;
 
    Probes();
 
  private:
    // NOLINTBEGIN
    Kokkos::View<double[buffer_size], Kokkos::LayoutRight, Kokkos::DefaultExecutionSpace> buffer;
    Kokkos::View<uint64_t, Kokkos::SharedSpace> internal_counter;
    Kokkos::View<double[buffer_size], Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace>
        host_buffer;
    // NOLINTEND
  };
 
  using ProbeAutogeneratedBuffer = Probes<AutoGenerated::probe_buffer_size>;
 
} // namespace Simulation
 
namespace Simulation
{
  template <std::size_t buffer_size>
  Probes<buffer_size>::Probes()
      : buffer("buffer"), internal_counter("i_c"), host_buffer("host_buffer")
  {
    clear();
  }
 
  template <std::size_t buffer_size>
  KOKKOS_INLINE_FUNCTION bool Probes<buffer_size>::set(double val) const
  {
    const auto i = Kokkos::atomic_fetch_inc(&internal_counter());
 
    //Innaccessible from host space if use CUDA because of direct assignment 
    if (i < buffer_size)
    {
      // this->buffer(i) = val;
      // if constexpr (is_view_accessible<decltype(buffer), Kokkos::DefaultExecutionSpace>())
      {
        this->buffer(i) = val;
      }
      // else
      // {
      //   // Kokkos::deep_copy(buffer(i), val);
      //   Kokkos::View<double, Kokkos::DefaultHostExecutionSpace> single_val("SingleValue");
      //   single_val() = val;
 
      //   Kokkos::deep_copy(buffer(i), single_val);
      // }
      return true;
    }
    return false;
  }
 
  template <std::size_t buffer_size> bool Probes<buffer_size>::need_export() const noexcept
  {
    return internal_counter() >= buffer_size;
  }
  template <std::size_t buffer_size> void Probes<buffer_size>::clear()
  {
    Kokkos::deep_copy(buffer, 0.);
    // Kokkos::deep_copy(host_buffer, 0);
    Kokkos::deep_copy(internal_counter, 0);
  }
 
  template <std::size_t buffer_size>
  [[nodiscard]] std::span<const double> Probes<buffer_size>::get() const
  {
    Kokkos::deep_copy(host_buffer, buffer);
    return {host_buffer.data(), std::min(buffer_size, internal_counter())};
  }
} // namespace Simulation
 
/* OLD IMPLEMENTATION
 
#include "biocma_cst_config.hpp"
#include "cmt_common/macro_constructor_assignment.hpp"
#include <Kokkos_Core.hpp>
#include <Kokkos_Core_fwd.hpp>
#include <Kokkos_Macros.hpp>
 
#include <cstdint>
#include <decl/Kokkos_Declare_OPENMP.hpp>
#include <initializer_list>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <traits/Kokkos_IterationPatternTrait.hpp>
namespace Simulation
{
 
  class Probes
  {
  public:
    static constexpr uint64_t buffer_size = AutoGenerated::probe_buffer_size;
 
    void clear();
 
    void set(double val) const;
 
    [[nodiscard]] bool need_export() const;
 
    [[nodiscard]] double* raw_get() const;
 
  private:
    using SubViewProbeType =
        Kokkos::Subview<Kokkos::View<double***, Kokkos::LayoutRight, ComputeSpace>,
                        decltype(Kokkos::ALL),
                        decltype(Kokkos::ALL),
                        size_t>;
 
    size_t n_p = 0;
    size_t n_t = 0;
    size_t n_s = 0;
    uint64_t get_counter = 0;
    [[deprecated]] Probes(std::string_view _label, uint64_t n_step, uint64_t n_compartments);
 
 
 
 
 
    Kokkos::View<double***, Kokkos::LayoutRight, ComputeSpace> probes;
    Kokkos::View<double***, Kokkos::LayoutRight, ComputeSpace> host;
    Kokkos::View<std::string*, HostSpace> labels;
 
    Kokkos::View<uint64_t, Kokkos::SharedSpace> internal_counter;
 
    Kokkos::View<double[Probes::buffer_size], Kokkos::LayoutRight, ComputeSpace> buffer;
 
  public:
    using SubViewTimeType =
        Kokkos::Subview<Kokkos::View<double***, Kokkos::LayoutRight, ComputeSpace>,
                        decltype(Kokkos::ALL),
                        size_t,
                        decltype(Kokkos::ALL)>;
    DEFAULT_COPY_MOVE_AC(Probes)
    ~Probes() = default;
    Probes(size_t initial_n_particle, size_t n_t_flush);
 
    Probes(size_t initial_n_particle, size_t n_t_flush, std::span<std::string> _labels);
 
    Probes(size_t initial_n_particle, size_t n_t_flush, std::initializer_list<std::string> _labels);
 
    [[deprecated]] void add_probe(std::string_view label);
    [[deprecated]] [[nodiscard]] std::span<std::string> get_labels() const;
 
    [[deprecated]] KOKKOS_FUNCTION std::optional<SubViewProbeType> get(std::string_view label);
 
    [[deprecated]] SubViewTimeType get();
 
    [[deprecated]] std::optional<std::array<size_t, 3>> get_raw(double** ptr);
  };
} // namespace Simulation
 
 
*/
 
#endif