VerletNeighborListAsBuild.h

Go to the documentation of this file.

 
#pragma once
 
#include "AsBuildPairGeneratorFunctor.h"
#include "C08TraversalColorChangeNotify.h"
#include "autopas/containers/verletListsCellBased/varVerletLists/neighborLists/VerletNeighborListInterface.h"
#include "autopas/utils/WrapOpenMP.h"
 
namespace autopas {
 
template <class Particle_T>
class VerletNeighborListAsBuild : public VerletNeighborListInterface<Particle_T>, ColorChangeObserver {
  friend class internal::AsBuildPairGeneratorFunctor<Particle_T, true>;
  friend class internal::AsBuildPairGeneratorFunctor<Particle_T, false>;
 
 private:
  template <bool useNewton3, bool validationMode = false>
  void applyGeneratorFunctor(double cutoff) {
    internal::AsBuildPairGeneratorFunctor<Particle_T, validationMode> generatorFunctor(*this, cutoff);
    // Use SoA traversal for generation and AoS traversal for validation check.
    constexpr auto dataLayout = validationMode ? DataLayoutOption::aos : DataLayoutOption::soa;
    auto traversal = C08TraversalColorChangeNotify<FullParticleCell<Particle_T>,
                                                   internal::AsBuildPairGeneratorFunctor<Particle_T, validationMode>>(
        _baseLinkedCells->getCellBlock().getCellsPerDimensionWithHalo(), &generatorFunctor,
        _baseLinkedCells->getInteractionLength(), _baseLinkedCells->getCellBlock().getCellLength(), this, dataLayout,
        useNewton3);
    _baseLinkedCells->computeInteractions(&traversal);
  }
 
 public:
  using AoSThreadNeighborList = std::unordered_map<Particle_T *, std::vector<Particle_T *>>;
  using AoSColorNeighborList = std::vector<AoSThreadNeighborList>;
 
  using SoAThreadNeighborList = std::vector<std::pair<size_t, std::vector<size_t, autopas::AlignedAllocator<size_t>>>>;
  using SoAColorNeighborList = std::vector<SoAThreadNeighborList>;
 
  VerletNeighborListAsBuild() : _aosNeighborList{}, _soaListIsValid(false) {}
 
  [[nodiscard]] ContainerOption getContainerType() const override { return ContainerOption::varVerletListsAsBuild; }
 
  void buildAoSNeighborList(LinkedCells<Particle_T> &linkedCells, bool useNewton3) override {
    _soaListIsValid = false;
    _baseLinkedCells = &linkedCells;
 
    auto maxNumThreads = autopas_get_max_threads();
    for (int color = 0; color < _numColors; color++) {
      _aosNeighborList[color].resize(maxNumThreads);
      for (auto &colorList : _aosNeighborList[color]) {
        colorList.clear();
      }
    }
 
    if (useNewton3) {
      applyGeneratorFunctor<true>(linkedCells.getInteractionLength());
    } else {
      applyGeneratorFunctor<false>(linkedCells.getInteractionLength());
    }
  }
 
  bool checkNeighborListValidity(bool useNewton3, double cutoff) override {
    _allPairsPresent = true;
    if (_baseLinkedCells == nullptr) return false;
 
    constexpr bool callCheck = true;
    if (useNewton3) {
      applyGeneratorFunctor<true, callCheck>(cutoff);
    } else {
      applyGeneratorFunctor<false, callCheck>(cutoff);
    }
 
    return _allPairsPresent;
  }
 
  const auto &getAoSNeighborList() { return _aosNeighborList; }
 
  const auto &getSoANeighborList() { return _soaNeighborList; }
 
  void receiveColorChange(unsigned long newColor) override { _currentColor = newColor; }
 
  void generateSoAFromAoS() override {
    // Generate a map from pointer to particle index in the SoA. This works, because during loadSoA"()" the particles
    // are loaded in the same order.
    std::unordered_map<Particle_T *, size_t> _aos2soaMap;
    _aos2soaMap.reserve(_baseLinkedCells->size());
    size_t i = 0;
    // needs to iterate also over dummies!
    for (auto iter = _baseLinkedCells->begin(IteratorBehavior::ownedOrHaloOrDummy); iter.isValid(); ++iter, ++i) {
      _aos2soaMap[&(*iter)] = i;
    }
 
    for (int color = 0; color < _numColors; color++) {
      unsigned int numThreads = _aosNeighborList[color].size();
      _soaNeighborList[color].resize(numThreads);
      AUTOPAS_OPENMP(parallel num_threads(numThreads))
      AUTOPAS_OPENMP(for schedule(static))
      for (unsigned int thread = 0; thread < numThreads; thread++) {
        auto &currentThreadList = _soaNeighborList[color][thread];
        currentThreadList.clear();
        for (const auto &pair : _aosNeighborList[color][thread]) {
          size_t indexFirst = _aos2soaMap[pair.first];
          std::vector<size_t, AlignedAllocator<size_t>> neighbors;
          neighbors.reserve(pair.second.size());
          for (const auto &second : pair.second) {
            size_t indexSecond = _aos2soaMap[second];
            neighbors.push_back(indexSecond);
          }
          currentThreadList.push_back({indexFirst, std::move(neighbors)});
        }
      }
    }
 
    _soaListIsValid = true;
  }
 
  template <class TFunctor>
  auto *loadSoA(TFunctor *f) {
    _soa.clear();
 
    // First resize the SoA to the required number of elements to store. This avoids resizing successively the SoA in
    // SoALoader.
    auto &cells = _baseLinkedCells->getCells();
    std::vector<size_t> offsets(cells.size() + 1);
    std::inclusive_scan(
        cells.begin(), cells.end(), offsets.begin() + 1,
        [](const size_t &partialSum, const auto &cell) { return partialSum + cell.size(); }, 0);
 
    _soa.resizeArrays(offsets.back());
 
    AUTOPAS_OPENMP(parallel for)
    for (size_t i = 0; i < cells.size(); ++i) {
      f->SoALoader(cells[i], _soa, offsets[i], /*skipSoAResize*/ true);
    }
 
    return &_soa;
  }
  template <class TFunctor>
  void extractSoA(TFunctor *f) {
    size_t offset = 0;
    for (auto &cell : _baseLinkedCells->getCells()) {
      f->SoAExtractor(cell, _soa, offset);
      offset += cell.size();
    }
  }
 
  bool isSoAListValid() const override { return _soaListIsValid; }
 
  long getNumberOfNeighborPairs() const override {
    long numPairs = 0;
    for (const auto &colorList : _aosNeighborList) {
      for (const auto &threadList : colorList) {
        numPairs += threadList.size();
      }
    }
    return numPairs;
  }
 
 private:
  void addPair(Particle_T *first, Particle_T *second) {
    int currentThreadIndex = autopas_get_thread_num();
    _aosNeighborList[_currentColor][currentThreadIndex][first].push_back(second);
  }
 
  void checkPair(Particle_T *first, Particle_T *second) {
    int currentThreadIndex = autopas_get_thread_num();
 
    // Check all neighbor lists for the pair, but the one that the pair would be in if it was not moved first.
    auto &oldThreadNeighborList = _aosNeighborList[_currentColor][currentThreadIndex];
    if (isPairInList(oldThreadNeighborList, first, second)) {
      for (int color = 0; color < _numColors; color++) {
        for (unsigned int thread = 0; thread < _aosNeighborList[color].size(); thread++) {
          if (not isPairInList(_aosNeighborList[_currentColor][currentThreadIndex], first, second)) {
            // this is thread safe, as _allPairsPresent is atomic
            _allPairsPresent = false;
            return;
          }
        }
      }
    } else {
      // this is thread safe, as _allPairsPresent is atomic
      _allPairsPresent = false;
    }
  }
 
  bool isPairInList(AoSThreadNeighborList &currentNeighborList, Particle_T *first, Particle_T *second) {
    auto iteratorFound = std::find(currentNeighborList[first].begin(), currentNeighborList[first].end(), second);
 
    return iteratorFound != currentNeighborList[first].end();
  }
 
 private:
  constexpr static size_t _numColors = 8;
 
  std::array<AoSColorNeighborList, _numColors> _aosNeighborList;
 
  LinkedCells<Particle_T> *_baseLinkedCells;
 
  std::array<SoAColorNeighborList, _numColors> _soaNeighborList;
 
  SoA<typename Particle_T::SoAArraysType> _soa;
 
  bool _soaListIsValid;
 
  int _currentColor{0};
 
  std::atomic<bool> _allPairsPresent;
};
 
}  // namespace autopas