VCLC01BalancedTraversal.h

Go to the documentation of this file.

 
#pragma once
 
#include "autopas/containers/verletClusterLists/traversals/VCLClusterFunctor.h"
#include "autopas/containers/verletClusterLists/traversals/VCLTraversalInterface.h"
#include "autopas/utils/WrapOpenMP.h"
 
namespace autopas {
 
template <class Particle_T, class PairwiseFunctor>
class VCLC01BalancedTraversal : public TraversalInterface, public VCLTraversalInterface<Particle_T> {
 public:
  explicit VCLC01BalancedTraversal(PairwiseFunctor &pairwiseFunctor, size_t clusterSize, DataLayoutOption dataLayout,
                                   bool useNewton3)
      : TraversalInterface(dataLayout, useNewton3),
        _functor(pairwiseFunctor),
        _clusterFunctor(pairwiseFunctor, clusterSize, dataLayout, useNewton3) {}
 
  [[nodiscard]] TraversalOption getTraversalType() const override { return TraversalOption::vcl_c01_balanced; }
 
  [[nodiscard]] bool isApplicableToDomain() const override { return true; }
 
  void initTraversal() override {
    if (_dataLayout != DataLayoutOption::soa) return;
 
    auto &clusterList = *VCLTraversalInterface<Particle_T>::_verletClusterLists;
    clusterList.loadParticlesIntoSoAs(_functor);
  }
 
  void endTraversal() override {
    if (_dataLayout != DataLayoutOption::soa) return;
 
    auto &clusterList = *VCLTraversalInterface<Particle_T>::_verletClusterLists;
    clusterList.extractParticlesFromSoAs(_functor);
  }
 
  void traverseParticles() override {
    auto &clusterList = *VCLTraversalInterface<Particle_T>::_verletClusterLists;
    auto &clusterThreadPartition = clusterList.getClusterThreadPartition();
 
    auto numThreads = clusterThreadPartition.size();
    AUTOPAS_OPENMP(parallel num_threads(numThreads)) {
      auto threadNum = autopas_get_thread_num();
      const auto &clusterRange = clusterThreadPartition[threadNum];
      auto &towers = *VCLTraversalInterface<Particle_T>::_towers;
      size_t clusterCount = 0;
      for (size_t towerIndex = clusterRange.startTowerIndex;
           clusterCount < clusterRange.numClusters and towerIndex < towers.size(); towerIndex++) {
        auto &currentTower = towers[towerIndex];
        auto startIndexInTower =
            clusterCount == 0 ? clusterRange.startIndexInTower : currentTower.getFirstOwnedClusterIndex();
        for (size_t clusterIndex = startIndexInTower;
             clusterCount < clusterRange.numClusters and clusterIndex < currentTower.getFirstTailHaloClusterIndex();
             clusterIndex++, clusterCount++) {
          const auto isHaloCluster = clusterIndex < currentTower.getFirstOwnedClusterIndex() or
                                     clusterIndex >= currentTower.getFirstTailHaloClusterIndex();
          _clusterFunctor.processCluster(currentTower.getCluster(clusterIndex), isHaloCluster);
        }
      }
      if (clusterCount != clusterRange.numClusters) {
        autopas::utils::ExceptionHandler::exception(
            "VCLC01BalancedTraversal::traverseParticlePairs(): Not all or too many clusters traversed, probably "
            "the clusterThreadPartitions are wrong! TraversedClusters={}, ClustersInRange={}",
            clusterCount, clusterRange.numClusters);
      }
    }
  }
 
  bool needsStaticClusterThreadPartition() override { return true; }
 
 private:
  PairwiseFunctor &_functor;
  internal::VCLClusterFunctor<Particle_T, PairwiseFunctor> _clusterFunctor;
};
}  // namespace autopas