Functor.h

Go to the documentation of this file.

 
#pragma once
 
#include <type_traits>
 
#include "autopas/options/DataLayoutOption.h"
#include "autopas/options/VectorizationPatternOption.h"
#include "autopas/utils/AlignedAllocator.h"
#include "autopas/utils/SoAView.h"
#include "autopas/utils/logging/FLOPLogger.h"
 
namespace autopas {
 
enum class FunctorN3Modes {
  Newton3Only,
  Newton3Off,
  Both,
};
 
template <class Particle_T, class CRTP_T>
class Functor {
 public:
  using SoAArraysType = typename Particle_T::SoAArraysType;
 
  using Functor_T = CRTP_T;
  explicit Functor(double cutoff) : _cutoff(cutoff){};
 
  virtual ~Functor() = default;
 
  virtual void initTraversal(){};
 
  virtual void endTraversal(bool newton3){};
 
  constexpr static std::array<typename Particle_T::AttributeNames, 0> getNeededAttr() {
    return std::array<typename Particle_T::AttributeNames, 0>{};
  }
 
  constexpr static std::array<typename Particle_T::AttributeNames, 0> getNeededAttr(std::false_type) {
    return Functor_T::getNeededAttr();
  }
 
  constexpr static std::array<typename Particle_T::AttributeNames, 0> getComputedAttr() {
    return std::array<typename Particle_T::AttributeNames, 0>{};
  }
 
  template <class ParticleCell>
  void SoALoader(ParticleCell &cell, SoA<SoAArraysType> &soa, size_t offset, bool skipSoAResize) {
    SoALoaderImpl(cell, soa, offset, skipSoAResize, std::make_index_sequence<Functor_T::getNeededAttr().size()>{});
  }
 
  template <typename ParticleCell>
  void SoAExtractor(ParticleCell &cell, SoA<SoAArraysType> &soa, size_t offset) {
    SoAExtractorImpl(cell, soa, offset, std::make_index_sequence<Functor_T::getComputedAttr().size()>{});
  }
 
  virtual bool allowsNewton3() = 0;
 
  virtual bool allowsNonNewton3() = 0;
 
  virtual bool isVecPatternAllowed(const VectorizationPatternOption::Value vecPattern) = 0;
 
  virtual bool isRelevantForTuning() = 0;
 
  virtual std::string getName() = 0;
 
  [[nodiscard]] double getCutoff() const { return _cutoff; }
 
  virtual void setVecPattern(const VectorizationPatternOption::Value vecPattern) {}
 
  [[nodiscard]] virtual size_t getNumFLOPs() const { return std::numeric_limits<size_t>::max(); }
 
  [[nodiscard]] virtual double getHitRate() const { return std::numeric_limits<double>::quiet_NaN(); }
 
 private:
  template <typename cell_t, std::size_t... I>
  void SoALoaderImpl(cell_t &cell, ::autopas::SoA<SoAArraysType> &soa, size_t offset, bool skipSoAResize,
                     std::index_sequence<I...>) {
    if (not skipSoAResize) {
      soa.resizeArrays(offset + cell.size());
    }
 
    if (cell.isEmpty()) return;
 
    // maybe_unused necessary because gcc doesn't understand that pointer is used later
    [[maybe_unused]] auto const pointer = std::make_tuple(soa.template begin<Functor_T::getNeededAttr()[I]>()...);
 
    auto cellIter = cell.begin();
    // load particles in SoAs
    for (size_t i = offset; cellIter != cell.end(); ++cellIter, ++i) {
      ((std::get<I>(pointer)[i] = cellIter->template get<Functor_T::getNeededAttr()[I]>()), ...);
    }
  }
 
  template <typename cell_t, std::size_t... I>
  void SoAExtractorImpl(cell_t &cell, ::autopas::SoA<SoAArraysType> &soa, size_t offset, std::index_sequence<I...>) {
    if (cell.isEmpty()) return;
 
    // maybe_unused necessary because gcc doesn't understand that pointer is used later
    [[maybe_unused]] auto const pointer = std::make_tuple(soa.template begin<Functor_T::getComputedAttr()[I]>()...);
 
    auto cellIter = cell.begin();
    // write values in SoAs back to particles
    for (size_t i = offset; cellIter != cell.end(); ++cellIter, ++i) {
      (cellIter->template set<Functor_T::getComputedAttr()[I]>(std::get<I>(pointer)[i]), ...);
    }
  }
 
  double _cutoff;
};
 
}  // namespace autopas